blob: fe8462bc7c2ed66cbb5a4cd501207bc4373d5016 [file] [log] [blame]
Chris Lattnerbed31442007-05-28 01:07:47 +00001//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnerbed31442007-05-28 01:07:47 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This coordinates the per-module state used while generating code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenModule.h"
Chris Lattner984fac52009-03-26 05:00:52 +000015#include "CGDebugInfo.h"
Chris Lattnerbed31442007-05-28 01:07:47 +000016#include "CodeGenFunction.h"
Dan Gohman947c9af2010-10-14 23:06:10 +000017#include "CodeGenTBAA.h"
Daniel Dunbar3d7c90b2008-09-08 21:33:45 +000018#include "CGCall.h"
John McCall5d865c322010-08-31 07:33:07 +000019#include "CGCXXABI.h"
Daniel Dunbar89da6ad2008-08-13 00:59:25 +000020#include "CGObjCRuntime.h"
Anton Korobeynikov55bcea12010-01-10 12:58:08 +000021#include "TargetInfo.h"
Chandler Carruth85098242010-06-15 23:19:56 +000022#include "clang/Frontend/CodeGenOptions.h"
Chris Lattner2ccb73b2007-06-16 00:16:26 +000023#include "clang/AST/ASTContext.h"
Ken Dyck98ca7942010-01-26 13:48:07 +000024#include "clang/AST/CharUnits.h"
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000025#include "clang/AST/DeclObjC.h"
Chris Lattnerb8c18fa2008-11-04 16:51:42 +000026#include "clang/AST/DeclCXX.h"
Douglas Gregor5dd34742010-06-21 18:41:26 +000027#include "clang/AST/DeclTemplate.h"
Peter Collingbourne0ff0b372011-01-13 18:57:25 +000028#include "clang/AST/Mangle.h"
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +000029#include "clang/AST/RecordLayout.h"
Chris Lattner15ba9492009-06-14 01:54:56 +000030#include "clang/Basic/Builtins.h"
Chris Lattnerd45aa2a2007-12-02 07:19:18 +000031#include "clang/Basic/Diagnostic.h"
Nate Begemanfaae0812008-04-19 04:17:09 +000032#include "clang/Basic/SourceManager.h"
Chris Lattner09153c02007-06-22 18:48:09 +000033#include "clang/Basic/TargetInfo.h"
Steve Naroff29cae662009-04-01 15:50:34 +000034#include "clang/Basic/ConvertUTF.h"
Nate Begemanaca747a2008-03-09 03:09:36 +000035#include "llvm/CallingConv.h"
Chris Lattner1eec6602007-08-31 04:31:45 +000036#include "llvm/Module.h"
Chris Lattner09153c02007-06-22 18:48:09 +000037#include "llvm/Intrinsics.h"
Chris Lattner5e124bf2009-12-28 21:44:41 +000038#include "llvm/LLVMContext.h"
John McCallbeec5a02010-03-06 00:35:14 +000039#include "llvm/ADT/Triple.h"
Rafael Espindolaac00f5d2011-02-10 23:59:36 +000040#include "llvm/Target/Mangler.h"
Anton Korobeynikov1200aca2008-06-01 14:13:53 +000041#include "llvm/Target/TargetData.h"
Gabor Greifd0ef1342010-04-10 02:56:12 +000042#include "llvm/Support/CallSite.h"
Chris Lattner15275e52009-11-07 09:22:46 +000043#include "llvm/Support/ErrorHandling.h"
Chris Lattnerbed31442007-05-28 01:07:47 +000044using namespace clang;
45using namespace CodeGen;
46
John McCall614dbdc2010-08-22 21:01:12 +000047static CGCXXABI &createCXXABI(CodeGenModule &CGM) {
48 switch (CGM.getContext().Target.getCXXABI()) {
49 case CXXABI_ARM: return *CreateARMCXXABI(CGM);
50 case CXXABI_Itanium: return *CreateItaniumCXXABI(CGM);
51 case CXXABI_Microsoft: return *CreateMicrosoftCXXABI(CGM);
52 }
53
54 llvm_unreachable("invalid C++ ABI kind");
55 return *CreateItaniumCXXABI(CGM);
56}
57
Chris Lattnerbed31442007-05-28 01:07:47 +000058
Chandler Carruthbc55fe22009-11-12 17:24:48 +000059CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
John McCall731be662010-03-04 04:29:44 +000060 llvm::Module &M, const llvm::TargetData &TD,
61 Diagnostic &diags)
John McCallad7c5c12011-02-08 08:22:06 +000062 : Context(C), Features(C.getLangOptions()), CodeGenOpts(CGO), TheModule(M),
John McCall731be662010-03-04 04:29:44 +000063 TheTargetData(TD), TheTargetCodeGenInfo(0), Diags(diags),
John McCall614dbdc2010-08-22 21:01:12 +000064 ABI(createCXXABI(*this)),
65 Types(C, M, TD, getTargetCodeGenInfo().getABIInfo(), ABI),
Dan Gohman947c9af2010-10-14 23:06:10 +000066 TBAA(0),
Devang Pateld6ffebb2011-03-07 18:45:56 +000067 VTables(*this), Runtime(0),
Fariborz Jahanian50c925f2010-10-19 17:19:29 +000068 CFConstantStringClassRef(0), ConstantStringClassRef(0),
Daniel Dunbar900546d2010-07-16 00:00:15 +000069 VMContext(M.getContext()),
Daniel Dunbar3348e2d2010-07-16 00:00:19 +000070 NSConcreteGlobalBlockDecl(0), NSConcreteStackBlockDecl(0),
Daniel Dunbar900546d2010-07-16 00:00:15 +000071 NSConcreteGlobalBlock(0), NSConcreteStackBlock(0),
Daniel Dunbar3348e2d2010-07-16 00:00:19 +000072 BlockObjectAssignDecl(0), BlockObjectDisposeDecl(0),
John McCallad7c5c12011-02-08 08:22:06 +000073 BlockObjectAssign(0), BlockObjectDispose(0),
74 BlockDescriptorType(0), GenericBlockLiteralType(0) {
David Chisnall067f0ed2011-03-22 21:21:24 +000075 if (Features.ObjC1)
76 createObjCRuntime();
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000077
Dan Gohman947c9af2010-10-14 23:06:10 +000078 // Enable TBAA unless it's suppressed.
79 if (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0)
Dan Gohman2e29eb52010-10-15 20:23:12 +000080 TBAA = new CodeGenTBAA(Context, VMContext, getLangOptions(),
81 ABI.getMangleContext());
Dan Gohman947c9af2010-10-14 23:06:10 +000082
Sanjiv Gupta15cb6692008-05-08 08:54:20 +000083 // If debug info generation is enabled, create the CGDebugInfo object.
Anders Carlsson3efc6e62009-12-06 18:00:51 +000084 DebugInfo = CodeGenOpts.DebugInfo ? new CGDebugInfo(*this) : 0;
John McCallad7c5c12011-02-08 08:22:06 +000085
86 Block.GlobalUniqueCount = 0;
John McCalle3dc1702011-02-15 09:22:45 +000087
88 // Initialize the type cache.
89 llvm::LLVMContext &LLVMContext = M.getContext();
90 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
91 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
92 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
93 PointerWidthInBits = C.Target.getPointerWidth(0);
John McCallc533cb72011-02-22 06:44:22 +000094 PointerAlignInBytes =
95 C.toCharUnitsFromBits(C.Target.getPointerAlign(0)).getQuantity();
John McCalle3dc1702011-02-15 09:22:45 +000096 IntTy = llvm::IntegerType::get(LLVMContext, C.Target.getIntWidth());
97 IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits);
98 Int8PtrTy = Int8Ty->getPointerTo(0);
99 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
Chris Lattnera087ff92008-03-01 08:45:05 +0000100}
101
102CodeGenModule::~CodeGenModule() {
Ted Kremenek2c674f62008-08-05 18:50:11 +0000103 delete Runtime;
John McCall614dbdc2010-08-22 21:01:12 +0000104 delete &ABI;
Dan Gohmand19ee8a2010-10-15 18:04:46 +0000105 delete TBAA;
Ted Kremenek2c674f62008-08-05 18:50:11 +0000106 delete DebugInfo;
107}
108
David Chisnall481e3a82010-01-23 02:40:42 +0000109void CodeGenModule::createObjCRuntime() {
110 if (!Features.NeXTRuntime)
111 Runtime = CreateGNUObjCRuntime(*this);
David Chisnall481e3a82010-01-23 02:40:42 +0000112 else
113 Runtime = CreateMacObjCRuntime(*this);
114}
115
Ted Kremenek2c674f62008-08-05 18:50:11 +0000116void CodeGenModule::Release() {
Chris Lattnera5ae54a2009-03-22 21:21:57 +0000117 EmitDeferred();
Eli Friedman5866fe32010-01-08 00:50:11 +0000118 EmitCXXGlobalInitFunc();
Daniel Dunbarfe06df42010-03-20 04:15:41 +0000119 EmitCXXGlobalDtorFunc();
Daniel Dunbar8d480592008-08-11 18:12:00 +0000120 if (Runtime)
121 if (llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction())
122 AddGlobalCtor(ObjCInitFunction);
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000123 EmitCtorList(GlobalCtors, "llvm.global_ctors");
124 EmitCtorList(GlobalDtors, "llvm.global_dtors");
Nate Begeman7fab5782008-04-18 23:43:57 +0000125 EmitAnnotations();
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000126 EmitLLVMUsed();
John McCall09ae0322010-07-06 23:57:41 +0000127
John McCall0bdb1fd2010-09-16 06:16:50 +0000128 SimplifyPersonality();
129
John McCall09ae0322010-07-06 23:57:41 +0000130 if (getCodeGenOpts().EmitDeclMetadata)
131 EmitDeclMetadata();
Daniel Dunbar23fd4622008-10-01 00:49:24 +0000132}
133
Devang Patel945b8ae2011-03-23 16:29:39 +0000134void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
135 // Make sure that this type is translated.
136 Types.UpdateCompletedType(TD);
137 if (DebugInfo)
138 DebugInfo->UpdateCompletedType(TD);
139}
140
Dan Gohman947c9af2010-10-14 23:06:10 +0000141llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) {
142 if (!TBAA)
143 return 0;
144 return TBAA->getTBAAInfo(QTy);
145}
146
147void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst,
148 llvm::MDNode *TBAAInfo) {
149 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo);
150}
151
John McCallbeec5a02010-03-06 00:35:14 +0000152bool CodeGenModule::isTargetDarwin() const {
153 return getContext().Target.getTriple().getOS() == llvm::Triple::Darwin;
154}
155
John McCall7ef5cb32011-03-18 02:56:14 +0000156void CodeGenModule::Error(SourceLocation loc, llvm::StringRef error) {
157 unsigned diagID = getDiags().getCustomDiagID(Diagnostic::Error, error);
158 getDiags().Report(Context.getFullLoc(loc), diagID);
159}
160
Daniel Dunbara7c8cf62008-08-16 00:56:44 +0000161/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerd45aa2a2007-12-02 07:19:18 +0000162/// specified stmt yet.
Daniel Dunbarf2cf6d12008-09-04 03:43:08 +0000163void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
164 bool OmitOnError) {
165 if (OmitOnError && getDiags().hasErrorOccurred())
166 return;
Mike Stump11289f42009-09-09 15:08:12 +0000167 unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
Daniel Dunbarfe2fb0a2009-02-06 19:18:03 +0000168 "cannot compile this %0 yet");
Chris Lattnerd45aa2a2007-12-02 07:19:18 +0000169 std::string Msg = Type;
Chris Lattner8488c822008-11-18 07:04:44 +0000170 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
171 << Msg << S->getSourceRange();
Chris Lattnerd45aa2a2007-12-02 07:19:18 +0000172}
Chris Lattner41af8182007-12-02 06:27:33 +0000173
Daniel Dunbara7c8cf62008-08-16 00:56:44 +0000174/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattner38376f12008-01-12 07:05:38 +0000175/// specified decl yet.
Daniel Dunbarf2cf6d12008-09-04 03:43:08 +0000176void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
177 bool OmitOnError) {
178 if (OmitOnError && getDiags().hasErrorOccurred())
179 return;
Mike Stump11289f42009-09-09 15:08:12 +0000180 unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
Daniel Dunbarfe2fb0a2009-02-06 19:18:03 +0000181 "cannot compile this %0 yet");
Chris Lattner38376f12008-01-12 07:05:38 +0000182 std::string Msg = Type;
Chris Lattner8488c822008-11-18 07:04:44 +0000183 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
Chris Lattner38376f12008-01-12 07:05:38 +0000184}
185
Mike Stump11289f42009-09-09 15:08:12 +0000186void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
Anders Carlssonc6a47892011-01-29 19:39:23 +0000187 const NamedDecl *D) const {
Daniel Dunbarf5f359f2009-04-14 06:00:08 +0000188 // Internal definitions always have default visibility.
Chris Lattner6a0f9072009-04-14 05:27:13 +0000189 if (GV->hasLocalLinkage()) {
Daniel Dunbard272cca2009-04-10 20:26:50 +0000190 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar15894b72009-04-07 05:48:37 +0000191 return;
Daniel Dunbard272cca2009-04-10 20:26:50 +0000192 }
Daniel Dunbar15894b72009-04-07 05:48:37 +0000193
John McCallc273f242010-10-30 11:50:40 +0000194 // Set visibility for definitions.
195 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility();
Rafael Espindola88ea6ab2011-02-01 05:45:26 +0000196 if (LV.visibilityExplicit() || !GV->hasAvailableExternallyLinkage())
197 GV->setVisibility(GetLLVMVisibility(LV.visibility()));
Dan Gohman75d69da2008-05-22 00:50:06 +0000198}
199
John McCalle16adc22010-08-04 08:34:44 +0000200/// Set the symbol visibility of type information (vtable and RTTI)
201/// associated with the given type.
202void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV,
203 const CXXRecordDecl *RD,
Anders Carlsson265aa7c2011-01-29 20:24:48 +0000204 TypeVisibilityKind TVK) const {
Anders Carlssonc6a47892011-01-29 19:39:23 +0000205 setGlobalVisibility(GV, RD);
John McCalle16adc22010-08-04 08:34:44 +0000206
John McCallb3732bb2010-08-12 23:36:15 +0000207 if (!CodeGenOpts.HiddenWeakVTables)
208 return;
209
Anders Carlsson678632f2011-01-29 20:36:11 +0000210 // We never want to drop the visibility for RTTI names.
211 if (TVK == TVK_ForRTTIName)
212 return;
213
John McCalle16adc22010-08-04 08:34:44 +0000214 // We want to drop the visibility to hidden for weak type symbols.
215 // This isn't possible if there might be unresolved references
216 // elsewhere that rely on this symbol being visible.
217
John McCall5513fce92010-08-05 20:39:18 +0000218 // This should be kept roughly in sync with setThunkVisibility
219 // in CGVTables.cpp.
220
John McCalle16adc22010-08-04 08:34:44 +0000221 // Preconditions.
Anders Carlsson571e2ad2011-01-24 00:46:19 +0000222 if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage ||
John McCalle16adc22010-08-04 08:34:44 +0000223 GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
224 return;
225
226 // Don't override an explicit visibility attribute.
Douglas Gregor1baf38f2011-03-26 12:10:19 +0000227 if (RD->getExplicitVisibility())
John McCalle16adc22010-08-04 08:34:44 +0000228 return;
229
230 switch (RD->getTemplateSpecializationKind()) {
231 // We have to disable the optimization if this is an EI definition
232 // because there might be EI declarations in other shared objects.
233 case TSK_ExplicitInstantiationDefinition:
234 case TSK_ExplicitInstantiationDeclaration:
235 return;
236
John McCall5513fce92010-08-05 20:39:18 +0000237 // Every use of a non-template class's type information has to emit it.
John McCalle16adc22010-08-04 08:34:44 +0000238 case TSK_Undeclared:
239 break;
240
John McCall5513fce92010-08-05 20:39:18 +0000241 // In theory, implicit instantiations can ignore the possibility of
242 // an explicit instantiation declaration because there necessarily
243 // must be an EI definition somewhere with default visibility. In
244 // practice, it's possible to have an explicit instantiation for
245 // an arbitrary template class, and linkers aren't necessarily able
246 // to deal with mixed-visibility symbols.
247 case TSK_ExplicitSpecialization:
John McCalle16adc22010-08-04 08:34:44 +0000248 case TSK_ImplicitInstantiation:
John McCallb3732bb2010-08-12 23:36:15 +0000249 if (!CodeGenOpts.HiddenWeakTemplateVTables)
John McCall5513fce92010-08-05 20:39:18 +0000250 return;
John McCalle16adc22010-08-04 08:34:44 +0000251 break;
252 }
253
254 // If there's a key function, there may be translation units
255 // that don't have the key function's definition. But ignore
256 // this if we're emitting RTTI under -fno-rtti.
Anders Carlsson265aa7c2011-01-29 20:24:48 +0000257 if (!(TVK != TVK_ForRTTI) || Features.RTTI) {
John McCalle16adc22010-08-04 08:34:44 +0000258 if (Context.getKeyFunction(RD))
259 return;
Anders Carlsson265aa7c2011-01-29 20:24:48 +0000260 }
John McCalle16adc22010-08-04 08:34:44 +0000261
262 // Otherwise, drop the visibility to hidden.
263 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Rafael Espindolab1e879c2011-01-11 21:44:37 +0000264 GV->setUnnamedAddr(true);
John McCalle16adc22010-08-04 08:34:44 +0000265}
266
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000267llvm::StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
268 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
269
270 llvm::StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()];
271 if (!Str.empty())
272 return Str;
273
John McCall5d865c322010-08-31 07:33:07 +0000274 if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000275 IdentifierInfo *II = ND->getIdentifier();
276 assert(II && "Attempt to mangle unnamed decl.");
277
278 Str = II->getName();
279 return Str;
280 }
281
282 llvm::SmallString<256> Buffer;
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000283 llvm::raw_svector_ostream Out(Buffer);
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000284 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000285 getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out);
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000286 else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000287 getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out);
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000288 else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND))
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000289 getCXXABI().getMangleContext().mangleBlock(BD, Out);
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000290 else
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000291 getCXXABI().getMangleContext().mangleName(ND, Out);
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000292
293 // Allocate space for the mangled name.
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000294 Out.flush();
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000295 size_t Length = Buffer.size();
296 char *Name = MangledNamesAllocator.Allocate<char>(Length);
297 std::copy(Buffer.begin(), Buffer.end(), Name);
298
299 Str = llvm::StringRef(Name, Length);
300
301 return Str;
302}
303
Peter Collingbourne0ff0b372011-01-13 18:57:25 +0000304void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer,
305 const BlockDecl *BD) {
306 MangleContext &MangleCtx = getCXXABI().getMangleContext();
307 const Decl *D = GD.getDecl();
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000308 llvm::raw_svector_ostream Out(Buffer.getBuffer());
Peter Collingbourne0ff0b372011-01-13 18:57:25 +0000309 if (D == 0)
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000310 MangleCtx.mangleGlobalBlock(BD, Out);
Peter Collingbourne0ff0b372011-01-13 18:57:25 +0000311 else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000312 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
Peter Collingbourne0ff0b372011-01-13 18:57:25 +0000313 else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D))
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000314 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
Peter Collingbourne0ff0b372011-01-13 18:57:25 +0000315 else
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000316 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
Anders Carlsson635186a2010-06-09 02:36:32 +0000317}
318
John McCall7ec50432010-03-19 23:29:14 +0000319llvm::GlobalValue *CodeGenModule::GetGlobalValue(llvm::StringRef Name) {
320 return getModule().getNamedValue(Name);
Douglas Gregor5fec5b02009-02-13 00:10:09 +0000321}
322
Chris Lattner5ff2d5d2008-03-14 17:18:18 +0000323/// AddGlobalCtor - Add a function to the list that will be called before
324/// main() runs.
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000325void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
Daniel Dunbardec798b2009-01-13 02:25:00 +0000326 // FIXME: Type coercion of void()* types.
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000327 GlobalCtors.push_back(std::make_pair(Ctor, Priority));
Chris Lattner5ff2d5d2008-03-14 17:18:18 +0000328}
329
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000330/// AddGlobalDtor - Add a function to the list that will be called
331/// when the module is unloaded.
332void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
Daniel Dunbardec798b2009-01-13 02:25:00 +0000333 // FIXME: Type coercion of void()* types.
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000334 GlobalDtors.push_back(std::make_pair(Dtor, Priority));
335}
336
337void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
338 // Ctor function type is void()*.
339 llvm::FunctionType* CtorFTy =
Benjamin Kramer1e188892011-01-22 12:15:57 +0000340 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000341 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000342
343 // Get the type of a ctor entry, { i32, void ()* }.
Mike Stump11289f42009-09-09 15:08:12 +0000344 llvm::StructType* CtorStructTy =
345 llvm::StructType::get(VMContext, llvm::Type::getInt32Ty(VMContext),
Owen Anderson9793f0e2009-07-29 22:16:19 +0000346 llvm::PointerType::getUnqual(CtorFTy), NULL);
Chris Lattner5ff2d5d2008-03-14 17:18:18 +0000347
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000348 // Construct the constructor and destructor arrays.
349 std::vector<llvm::Constant*> Ctors;
350 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
351 std::vector<llvm::Constant*> S;
Mike Stump11289f42009-09-09 15:08:12 +0000352 S.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
Owen Anderson41a75022009-08-13 21:57:51 +0000353 I->second, false));
Owen Andersonade90fd2009-07-29 18:54:39 +0000354 S.push_back(llvm::ConstantExpr::getBitCast(I->first, CtorPFTy));
Owen Anderson0e0189d2009-07-27 22:29:56 +0000355 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
Chris Lattner5ff2d5d2008-03-14 17:18:18 +0000356 }
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000357
358 if (!Ctors.empty()) {
Owen Anderson9793f0e2009-07-29 22:16:19 +0000359 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
Owen Andersonc10c8d32009-07-08 19:05:04 +0000360 new llvm::GlobalVariable(TheModule, AT, false,
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000361 llvm::GlobalValue::AppendingLinkage,
Owen Anderson47034e12009-07-28 18:33:04 +0000362 llvm::ConstantArray::get(AT, Ctors),
Owen Andersonc10c8d32009-07-08 19:05:04 +0000363 GlobalName);
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000364 }
Chris Lattner5ff2d5d2008-03-14 17:18:18 +0000365}
366
Nate Begeman7fab5782008-04-18 23:43:57 +0000367void CodeGenModule::EmitAnnotations() {
368 if (Annotations.empty())
369 return;
370
371 // Create a new global variable for the ConstantStruct in the Module.
372 llvm::Constant *Array =
Owen Anderson9793f0e2009-07-29 22:16:19 +0000373 llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(),
Nate Begeman7fab5782008-04-18 23:43:57 +0000374 Annotations.size()),
375 Annotations);
Mike Stump11289f42009-09-09 15:08:12 +0000376 llvm::GlobalValue *gv =
377 new llvm::GlobalVariable(TheModule, Array->getType(), false,
378 llvm::GlobalValue::AppendingLinkage, Array,
Owen Andersonc10c8d32009-07-08 19:05:04 +0000379 "llvm.global.annotations");
Nate Begeman7fab5782008-04-18 23:43:57 +0000380 gv->setSection("llvm.metadata");
381}
382
John McCalld4324142010-02-19 01:32:20 +0000383llvm::GlobalValue::LinkageTypes
384CodeGenModule::getFunctionLinkage(const FunctionDecl *D) {
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +0000385 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
Daniel Dunbar38932572009-04-14 08:05:55 +0000386
Chris Lattner749b8ed2010-06-30 16:58:07 +0000387 if (Linkage == GVA_Internal)
John McCalld4324142010-02-19 01:32:20 +0000388 return llvm::Function::InternalLinkage;
Chris Lattner749b8ed2010-06-30 16:58:07 +0000389
390 if (D->hasAttr<DLLExportAttr>())
John McCalld4324142010-02-19 01:32:20 +0000391 return llvm::Function::DLLExportLinkage;
Chris Lattner749b8ed2010-06-30 16:58:07 +0000392
393 if (D->hasAttr<WeakAttr>())
John McCalld4324142010-02-19 01:32:20 +0000394 return llvm::Function::WeakAnyLinkage;
Chris Lattner749b8ed2010-06-30 16:58:07 +0000395
396 // In C99 mode, 'inline' functions are guaranteed to have a strong
397 // definition somewhere else, so we can use available_externally linkage.
398 if (Linkage == GVA_C99Inline)
Fariborz Jahanian7cadb2f2011-02-04 00:08:13 +0000399 return llvm::Function::AvailableExternallyLinkage;
Chris Lattner749b8ed2010-06-30 16:58:07 +0000400
401 // In C++, the compiler has to emit a definition in every translation unit
402 // that references the function. We should use linkonce_odr because
403 // a) if all references in this translation unit are optimized away, we
404 // don't need to codegen it. b) if the function persists, it needs to be
405 // merged with other definitions. c) C++ has the ODR, so we know the
406 // definition is dependable.
407 if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
Fariborz Jahanianf7f04452011-02-04 00:01:24 +0000408 return !Context.getLangOptions().AppleKext
409 ? llvm::Function::LinkOnceODRLinkage
410 : llvm::Function::InternalLinkage;
Chris Lattner749b8ed2010-06-30 16:58:07 +0000411
412 // An explicit instantiation of a template has weak linkage, since
413 // explicit instantiations can occur in multiple translation units
414 // and must all be equivalent. However, we are not allowed to
415 // throw away these explicit instantiations.
416 if (Linkage == GVA_ExplicitTemplateInstantiation)
Fariborz Jahanianf7f04452011-02-04 00:01:24 +0000417 return !Context.getLangOptions().AppleKext
418 ? llvm::Function::WeakODRLinkage
419 : llvm::Function::InternalLinkage;
Chris Lattner749b8ed2010-06-30 16:58:07 +0000420
421 // Otherwise, we have strong external linkage.
422 assert(Linkage == GVA_StrongExternal);
423 return llvm::Function::ExternalLinkage;
John McCalld4324142010-02-19 01:32:20 +0000424}
Nuno Lopesb6f79532008-06-08 15:45:52 +0000425
John McCalld4324142010-02-19 01:32:20 +0000426
427/// SetFunctionDefinitionAttributes - Set attributes for a global.
428///
429/// FIXME: This is currently only done for aliases and functions, but not for
430/// variables (these details are set in EmitGlobalVarDefinition for variables).
431void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
432 llvm::GlobalValue *GV) {
Daniel Dunbar38932572009-04-14 08:05:55 +0000433 SetCommonAttributes(D, GV);
Nuno Lopesb6f79532008-06-08 15:45:52 +0000434}
435
Daniel Dunbaraeddffc2009-04-14 07:08:30 +0000436void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
Mike Stump11289f42009-09-09 15:08:12 +0000437 const CGFunctionInfo &Info,
Daniel Dunbaraeddffc2009-04-14 07:08:30 +0000438 llvm::Function *F) {
Daniel Dunbar0ef34792009-09-12 00:59:20 +0000439 unsigned CallingConv;
Devang Patel322300d2008-09-25 21:02:23 +0000440 AttributeListType AttributeList;
Daniel Dunbar0ef34792009-09-12 00:59:20 +0000441 ConstructAttributeList(Info, D, AttributeList, CallingConv);
Devang Patel322300d2008-09-25 21:02:23 +0000442 F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(),
Daniel Dunbar0ef34792009-09-12 00:59:20 +0000443 AttributeList.size()));
444 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbar449a3392008-09-04 23:41:35 +0000445}
446
Daniel Dunbar38932572009-04-14 08:05:55 +0000447void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
448 llvm::Function *F) {
Daniel Dunbar0f3403c2009-03-02 04:58:03 +0000449 if (!Features.Exceptions && !Features.ObjCNonFragileABI)
Mike Stump11289f42009-09-09 15:08:12 +0000450 F->addFnAttr(llvm::Attribute::NoUnwind);
Daniel Dunbar03a38442008-10-28 00:17:57 +0000451
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000452 if (D->hasAttr<AlwaysInlineAttr>())
Daniel Dunbar03a38442008-10-28 00:17:57 +0000453 F->addFnAttr(llvm::Attribute::AlwaysInline);
Mike Stump11289f42009-09-09 15:08:12 +0000454
Daniel Dunbar8caf6412010-09-29 18:20:25 +0000455 if (D->hasAttr<NakedAttr>())
456 F->addFnAttr(llvm::Attribute::Naked);
457
Mike Stump3722f582009-08-26 22:31:08 +0000458 if (D->hasAttr<NoInlineAttr>())
Anders Carlssonf96954c2009-02-19 19:22:11 +0000459 F->addFnAttr(llvm::Attribute::NoInline);
Mike Stumpc5e153c2009-10-05 21:58:44 +0000460
Rafael Espindola0ee986c1f2011-01-11 00:26:26 +0000461 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
462 F->setUnnamedAddr(true);
463
Anders Carlsson0d82fa62009-11-16 16:56:03 +0000464 if (Features.getStackProtectorMode() == LangOptions::SSPOn)
465 F->addFnAttr(llvm::Attribute::StackProtect);
466 else if (Features.getStackProtectorMode() == LangOptions::SSPReq)
467 F->addFnAttr(llvm::Attribute::StackProtectReq);
468
Alexis Huntdcfba7b2010-08-18 23:23:40 +0000469 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
470 if (alignment)
471 F->setAlignment(alignment);
472
Mike Stump3472ae52009-10-05 22:49:20 +0000473 // C++ ABI requires 2-byte alignment for member functions.
Mike Stump916c0062009-10-05 23:08:21 +0000474 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
475 F->setAlignment(2);
Daniel Dunbar449a3392008-09-04 23:41:35 +0000476}
477
Mike Stump11289f42009-09-09 15:08:12 +0000478void CodeGenModule::SetCommonAttributes(const Decl *D,
Daniel Dunbar38932572009-04-14 08:05:55 +0000479 llvm::GlobalValue *GV) {
Anders Carlsson072ef742011-01-29 19:41:00 +0000480 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
481 setGlobalVisibility(GV, ND);
John McCall457a04e2010-10-22 21:05:15 +0000482 else
483 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar38932572009-04-14 08:05:55 +0000484
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000485 if (D->hasAttr<UsedAttr>())
Daniel Dunbar38932572009-04-14 08:05:55 +0000486 AddUsedGlobal(GV);
487
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000488 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
Daniel Dunbar38932572009-04-14 08:05:55 +0000489 GV->setSection(SA->getName());
Anton Korobeynikov55bcea12010-01-10 12:58:08 +0000490
491 getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
Daniel Dunbar38932572009-04-14 08:05:55 +0000492}
493
Daniel Dunbarc3e7cff2009-04-17 00:48:04 +0000494void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
495 llvm::Function *F,
496 const CGFunctionInfo &FI) {
497 SetLLVMFunctionAttributes(D, FI, F);
498 SetLLVMFunctionAttributesForDefinition(D, F);
Daniel Dunbar38932572009-04-14 08:05:55 +0000499
500 F->setLinkage(llvm::Function::InternalLinkage);
501
Daniel Dunbarc3e7cff2009-04-17 00:48:04 +0000502 SetCommonAttributes(D, F);
Daniel Dunbar449a3392008-09-04 23:41:35 +0000503}
504
Anders Carlsson6710c532010-02-06 02:44:09 +0000505void CodeGenModule::SetFunctionAttributes(GlobalDecl GD,
Eli Friedman895771a2009-05-26 01:22:57 +0000506 llvm::Function *F,
507 bool IsIncompleteFunction) {
Peter Collingbourneeafa4e42011-04-06 12:29:04 +0000508 if (unsigned IID = F->getIntrinsicID()) {
509 // If this is an intrinsic function, set the function's attributes
510 // to the intrinsic's attributes.
511 F->setAttributes(llvm::Intrinsic::getAttributes((llvm::Intrinsic::ID)IID));
512 return;
513 }
514
Anders Carlsson6710c532010-02-06 02:44:09 +0000515 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
516
Eli Friedman895771a2009-05-26 01:22:57 +0000517 if (!IsIncompleteFunction)
Anders Carlsson6710c532010-02-06 02:44:09 +0000518 SetLLVMFunctionAttributes(FD, getTypes().getFunctionInfo(GD), F);
Mike Stump11289f42009-09-09 15:08:12 +0000519
Daniel Dunbar38932572009-04-14 08:05:55 +0000520 // Only a few attributes are set on declarations; these may later be
521 // overridden by a definition.
Mike Stump11289f42009-09-09 15:08:12 +0000522
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000523 if (FD->hasAttr<DLLImportAttr>()) {
Daniel Dunbar38932572009-04-14 08:05:55 +0000524 F->setLinkage(llvm::Function::DLLImportLinkage);
Mike Stump11289f42009-09-09 15:08:12 +0000525 } else if (FD->hasAttr<WeakAttr>() ||
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000526 FD->isWeakImported()) {
Daniel Dunbar38932572009-04-14 08:05:55 +0000527 // "extern_weak" is overloaded in LLVM; we probably should have
Mike Stump11289f42009-09-09 15:08:12 +0000528 // separate linkage types for this.
Daniel Dunbar38932572009-04-14 08:05:55 +0000529 F->setLinkage(llvm::Function::ExternalWeakLinkage);
530 } else {
Mike Stump11289f42009-09-09 15:08:12 +0000531 F->setLinkage(llvm::Function::ExternalLinkage);
John McCallc273f242010-10-30 11:50:40 +0000532
533 NamedDecl::LinkageInfo LV = FD->getLinkageAndVisibility();
534 if (LV.linkage() == ExternalLinkage && LV.visibilityExplicit()) {
535 F->setVisibility(GetLLVMVisibility(LV.visibility()));
536 }
Daniel Dunbar38932572009-04-14 08:05:55 +0000537 }
538
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000539 if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
Daniel Dunbar38932572009-04-14 08:05:55 +0000540 F->setSection(SA->getName());
Daniel Dunbar0beedc12008-09-08 23:44:31 +0000541}
542
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000543void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
Mike Stump11289f42009-09-09 15:08:12 +0000544 assert(!GV->isDeclaration() &&
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000545 "Only globals with definition can force usage.");
Chris Lattnerf41e87f2009-03-31 22:37:52 +0000546 LLVMUsed.push_back(GV);
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000547}
548
549void CodeGenModule::EmitLLVMUsed() {
550 // Don't create llvm.used if there is no need.
Chris Lattnerf56501c2009-07-17 23:57:13 +0000551 if (LLVMUsed.empty())
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000552 return;
553
Benjamin Kramerabd5b902009-10-13 10:07:13 +0000554 const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext);
Mike Stump11289f42009-09-09 15:08:12 +0000555
Chris Lattnerf41e87f2009-03-31 22:37:52 +0000556 // Convert LLVMUsed to what ConstantArray needs.
557 std::vector<llvm::Constant*> UsedArray;
558 UsedArray.resize(LLVMUsed.size());
559 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
Mike Stump11289f42009-09-09 15:08:12 +0000560 UsedArray[i] =
561 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
Owen Anderson170229f2009-07-14 23:10:40 +0000562 i8PTy);
Chris Lattnerf41e87f2009-03-31 22:37:52 +0000563 }
Mike Stump11289f42009-09-09 15:08:12 +0000564
Fariborz Jahanian248c7192009-06-23 21:47:46 +0000565 if (UsedArray.empty())
566 return;
Owen Anderson9793f0e2009-07-29 22:16:19 +0000567 llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, UsedArray.size());
Mike Stump11289f42009-09-09 15:08:12 +0000568
569 llvm::GlobalVariable *GV =
570 new llvm::GlobalVariable(getModule(), ATy, false,
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000571 llvm::GlobalValue::AppendingLinkage,
Owen Anderson47034e12009-07-28 18:33:04 +0000572 llvm::ConstantArray::get(ATy, UsedArray),
Owen Andersonc10c8d32009-07-08 19:05:04 +0000573 "llvm.used");
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000574
575 GV->setSection("llvm.metadata");
576}
577
578void CodeGenModule::EmitDeferred() {
Chris Lattner45470942009-03-21 09:44:56 +0000579 // Emit code for any potentially referenced deferred decls. Since a
580 // previously unused static decl may become used during the generation of code
581 // for a static function, iterate until no changes are made.
Rafael Espindolae7113ca2010-03-10 02:19:29 +0000582
Anders Carlsson11e51402010-04-17 20:15:18 +0000583 while (!DeferredDeclsToEmit.empty() || !DeferredVTables.empty()) {
584 if (!DeferredVTables.empty()) {
585 const CXXRecordDecl *RD = DeferredVTables.back();
586 DeferredVTables.pop_back();
587 getVTables().GenerateClassData(getVTableLinkage(RD), RD);
Rafael Espindolae7113ca2010-03-10 02:19:29 +0000588 continue;
589 }
590
Anders Carlssondae1abc2009-05-05 04:44:02 +0000591 GlobalDecl D = DeferredDeclsToEmit.back();
Chris Lattner45470942009-03-21 09:44:56 +0000592 DeferredDeclsToEmit.pop_back();
593
John McCallc2af9392010-05-27 01:45:30 +0000594 // Check to see if we've already emitted this. This is necessary
595 // for a couple of reasons: first, decls can end up in the
596 // deferred-decls queue multiple times, and second, decls can end
597 // up with definitions in unusual ways (e.g. by an extern inline
598 // function acquiring a strong function redefinition). Just
599 // ignore these cases.
600 //
601 // TODO: That said, looking this up multiple times is very wasteful.
Anders Carlssonea836bc2010-06-22 16:16:50 +0000602 llvm::StringRef Name = getMangledName(D);
John McCall7ec50432010-03-19 23:29:14 +0000603 llvm::GlobalValue *CGRef = GetGlobalValue(Name);
Chris Lattner45470942009-03-21 09:44:56 +0000604 assert(CGRef && "Deferred decl wasn't referenced?");
Mike Stump11289f42009-09-09 15:08:12 +0000605
Chris Lattner45470942009-03-21 09:44:56 +0000606 if (!CGRef->isDeclaration())
607 continue;
Mike Stump11289f42009-09-09 15:08:12 +0000608
John McCallc2af9392010-05-27 01:45:30 +0000609 // GlobalAlias::isDeclaration() defers to the aliasee, but for our
610 // purposes an alias counts as a definition.
611 if (isa<llvm::GlobalAlias>(CGRef))
612 continue;
613
Chris Lattner45470942009-03-21 09:44:56 +0000614 // Otherwise, emit the definition and move on to the next one.
615 EmitGlobalDefinition(D);
616 }
Chris Lattnerbed31442007-05-28 01:07:47 +0000617}
Chris Lattner09153c02007-06-22 18:48:09 +0000618
Mike Stump11289f42009-09-09 15:08:12 +0000619/// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the
Nate Begemanfaae0812008-04-19 04:17:09 +0000620/// annotation information for a given GlobalValue. The annotation struct is
Mike Stump11289f42009-09-09 15:08:12 +0000621/// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the
622/// GlobalValue being annotated. The second field is the constant string
623/// created from the AnnotateAttr's annotation. The third field is a constant
Nate Begemanfaae0812008-04-19 04:17:09 +0000624/// string containing the name of the translation unit. The fourth field is
625/// the line number in the file of the annotated value declaration.
626///
627/// FIXME: this does not unique the annotation string constants, as llvm-gcc
628/// appears to.
629///
Mike Stump11289f42009-09-09 15:08:12 +0000630llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
Nate Begemanfaae0812008-04-19 04:17:09 +0000631 const AnnotateAttr *AA,
632 unsigned LineNo) {
633 llvm::Module *M = &getModule();
634
635 // get [N x i8] constants for the annotation string, and the filename string
636 // which are the 2nd and 3rd elements of the global annotation structure.
Benjamin Kramerabd5b902009-10-13 10:07:13 +0000637 const llvm::Type *SBP = llvm::Type::getInt8PtrTy(VMContext);
Mike Stump11289f42009-09-09 15:08:12 +0000638 llvm::Constant *anno = llvm::ConstantArray::get(VMContext,
Owen Anderson41a75022009-08-13 21:57:51 +0000639 AA->getAnnotation(), true);
640 llvm::Constant *unit = llvm::ConstantArray::get(VMContext,
641 M->getModuleIdentifier(),
Nate Begemanfaae0812008-04-19 04:17:09 +0000642 true);
643
644 // Get the two global values corresponding to the ConstantArrays we just
645 // created to hold the bytes of the strings.
Mike Stump11289f42009-09-09 15:08:12 +0000646 llvm::GlobalValue *annoGV =
Chris Lattner3afa3e12009-07-16 05:03:48 +0000647 new llvm::GlobalVariable(*M, anno->getType(), false,
648 llvm::GlobalValue::PrivateLinkage, anno,
649 GV->getName());
Nate Begemanfaae0812008-04-19 04:17:09 +0000650 // translation unit name string, emitted into the llvm.metadata section.
651 llvm::GlobalValue *unitGV =
Chris Lattner3afa3e12009-07-16 05:03:48 +0000652 new llvm::GlobalVariable(*M, unit->getType(), false,
Mike Stump11289f42009-09-09 15:08:12 +0000653 llvm::GlobalValue::PrivateLinkage, unit,
Chris Lattner3afa3e12009-07-16 05:03:48 +0000654 ".str");
Rafael Espindola2e217d62011-01-17 22:22:52 +0000655 unitGV->setUnnamedAddr(true);
Nate Begemanfaae0812008-04-19 04:17:09 +0000656
Daniel Dunbar346892a2009-04-14 22:41:13 +0000657 // Create the ConstantStruct for the global annotation.
Nate Begemanfaae0812008-04-19 04:17:09 +0000658 llvm::Constant *Fields[4] = {
Owen Andersonade90fd2009-07-29 18:54:39 +0000659 llvm::ConstantExpr::getBitCast(GV, SBP),
660 llvm::ConstantExpr::getBitCast(annoGV, SBP),
661 llvm::ConstantExpr::getBitCast(unitGV, SBP),
Owen Anderson41a75022009-08-13 21:57:51 +0000662 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), LineNo)
Nate Begemanfaae0812008-04-19 04:17:09 +0000663 };
Owen Anderson758428f2009-08-05 23:18:46 +0000664 return llvm::ConstantStruct::get(VMContext, Fields, 4, false);
Nate Begemanfaae0812008-04-19 04:17:09 +0000665}
666
Argyrios Kyrtzidisc0279a92010-07-27 22:37:14 +0000667bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +0000668 // Never defer when EmitAllDecls is specified.
669 if (Features.EmitAllDecls)
Daniel Dunbar6b8720e2009-02-13 21:18:01 +0000670 return false;
Daniel Dunbar9c426522008-07-29 23:18:29 +0000671
Argyrios Kyrtzidisc9049332010-07-29 20:08:05 +0000672 return !getContext().DeclMustBeEmitted(Global);
Daniel Dunbar6b8720e2009-02-13 21:18:01 +0000673}
674
Rafael Espindola2e42fec2010-03-04 18:17:24 +0000675llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
676 const AliasAttr *AA = VD->getAttr<AliasAttr>();
677 assert(AA && "No alias?");
678
679 const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
680
Rafael Espindola2e42fec2010-03-04 18:17:24 +0000681 // See if there is already something with the target's name in the module.
John McCall7ec50432010-03-19 23:29:14 +0000682 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
Rafael Espindola2e42fec2010-03-04 18:17:24 +0000683
684 llvm::Constant *Aliasee;
685 if (isa<llvm::FunctionType>(DeclTy))
Anders Carlsson3c239482011-02-05 04:35:53 +0000686 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl(),
687 /*ForVTable=*/false);
Rafael Espindola2e42fec2010-03-04 18:17:24 +0000688 else
John McCall7ec50432010-03-19 23:29:14 +0000689 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Rafael Espindola2e42fec2010-03-04 18:17:24 +0000690 llvm::PointerType::getUnqual(DeclTy), 0);
691 if (!Entry) {
692 llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee);
693 F->setLinkage(llvm::Function::ExternalWeakLinkage);
694 WeakRefReferences.insert(F);
695 }
696
697 return Aliasee;
698}
699
Chris Lattnere0be0df2009-05-12 21:21:08 +0000700void CodeGenModule::EmitGlobal(GlobalDecl GD) {
Anders Carlsson38988d72009-09-10 23:38:47 +0000701 const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
Mike Stump11289f42009-09-09 15:08:12 +0000702
Rafael Espindola2e42fec2010-03-04 18:17:24 +0000703 // Weak references don't produce any output by themselves.
704 if (Global->hasAttr<WeakRefAttr>())
705 return;
706
Chris Lattner54041692009-03-22 21:47:11 +0000707 // If this is an alias definition (which otherwise looks like a declaration)
708 // emit it now.
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000709 if (Global->hasAttr<AliasAttr>())
John McCall7ec50432010-03-19 23:29:14 +0000710 return EmitAliasDefinition(GD);
Daniel Dunbar0beedc12008-09-08 23:44:31 +0000711
Chris Lattner45470942009-03-21 09:44:56 +0000712 // Ignore declarations, they will be emitted on their first use.
Daniel Dunbar4e004ed2009-03-19 08:27:24 +0000713 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
Daniel Dunbar3348e2d2010-07-16 00:00:19 +0000714 if (FD->getIdentifier()) {
715 llvm::StringRef Name = FD->getName();
716 if (Name == "_Block_object_assign") {
717 BlockObjectAssignDecl = FD;
718 } else if (Name == "_Block_object_dispose") {
719 BlockObjectDisposeDecl = FD;
720 }
721 }
722
Daniel Dunbar6b8720e2009-02-13 21:18:01 +0000723 // Forward declarations are emitted lazily on first use.
724 if (!FD->isThisDeclarationADefinition())
725 return;
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000726 } else {
727 const VarDecl *VD = cast<VarDecl>(Global);
Daniel Dunbar9c426522008-07-29 23:18:29 +0000728 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
729
Daniel Dunbar3348e2d2010-07-16 00:00:19 +0000730 if (VD->getIdentifier()) {
731 llvm::StringRef Name = VD->getName();
732 if (Name == "_NSConcreteGlobalBlock") {
733 NSConcreteGlobalBlockDecl = VD;
734 } else if (Name == "_NSConcreteStackBlock") {
735 NSConcreteStackBlockDecl = VD;
736 }
737 }
738
739
Douglas Gregor61f6db52010-02-06 05:15:45 +0000740 if (VD->isThisDeclarationADefinition() != VarDecl::Definition)
Douglas Gregorbeecd582009-04-21 17:11:58 +0000741 return;
Nate Begeman8e8d4982008-04-20 06:29:50 +0000742 }
743
Chris Lattner45470942009-03-21 09:44:56 +0000744 // Defer code generation when possible if this is a static definition, inline
745 // function etc. These we only want to emit if they are used.
Chris Lattner7a4a29f2010-04-13 17:39:09 +0000746 if (!MayDeferGeneration(Global)) {
747 // Emit the definition if it can't be deferred.
748 EmitGlobalDefinition(GD);
Daniel Dunbar9c426522008-07-29 23:18:29 +0000749 return;
750 }
John McCall70013b62010-07-15 23:40:35 +0000751
752 // If we're deferring emission of a C++ variable with an
753 // initializer, remember the order in which it appeared in the file.
754 if (getLangOptions().CPlusPlus && isa<VarDecl>(Global) &&
755 cast<VarDecl>(Global)->hasInit()) {
756 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
757 CXXGlobalInits.push_back(0);
758 }
Chris Lattner7a4a29f2010-04-13 17:39:09 +0000759
760 // If the value has already been used, add it directly to the
761 // DeferredDeclsToEmit list.
Anders Carlssonea836bc2010-06-22 16:16:50 +0000762 llvm::StringRef MangledName = getMangledName(GD);
Chris Lattner7a4a29f2010-04-13 17:39:09 +0000763 if (GetGlobalValue(MangledName))
764 DeferredDeclsToEmit.push_back(GD);
765 else {
766 // Otherwise, remember that we saw a deferred decl with this name. The
767 // first use of the mangled name will cause it to move into
768 // DeferredDeclsToEmit.
769 DeferredDecls[MangledName] = GD;
770 }
Nate Begeman8e8d4982008-04-20 06:29:50 +0000771}
772
Chris Lattnere0be0df2009-05-12 21:21:08 +0000773void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
Anders Carlsson38988d72009-09-10 23:38:47 +0000774 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Mike Stump11289f42009-09-09 15:08:12 +0000775
Dan Gohman145f3f12010-04-19 16:39:44 +0000776 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
Anders Carlsson29295bf2009-10-27 14:32:27 +0000777 Context.getSourceManager(),
778 "Generating code for declaration");
779
Douglas Gregora700f682010-07-13 06:02:28 +0000780 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
781 // At -O0, don't generate IR for functions with available_externally
782 // linkage.
Douglas Gregor89976902010-07-15 22:58:18 +0000783 if (CodeGenOpts.OptimizationLevel == 0 &&
784 !Function->hasAttr<AlwaysInlineAttr>() &&
Douglas Gregora700f682010-07-13 06:02:28 +0000785 getFunctionLinkage(Function)
786 == llvm::Function::AvailableExternallyLinkage)
787 return;
Anders Carlssonaf82f632010-03-23 04:31:31 +0000788
Douglas Gregora700f682010-07-13 06:02:28 +0000789 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
790 if (Method->isVirtual())
791 getVTables().EmitThunks(GD);
792
793 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
794 return EmitCXXConstructor(CD, GD.getCtorType());
Chris Lattner7a4a29f2010-04-13 17:39:09 +0000795
Douglas Gregora700f682010-07-13 06:02:28 +0000796 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(Method))
797 return EmitCXXDestructor(DD, GD.getDtorType());
798 }
Chris Lattnerd8d760c2010-04-13 17:57:11 +0000799
Chris Lattnerd8d760c2010-04-13 17:57:11 +0000800 return EmitGlobalFunctionDefinition(GD);
Douglas Gregora700f682010-07-13 06:02:28 +0000801 }
Chris Lattnerd8d760c2010-04-13 17:57:11 +0000802
803 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
804 return EmitGlobalVarDefinition(VD);
Chris Lattner7a4a29f2010-04-13 17:39:09 +0000805
806 assert(0 && "Invalid argument to EmitGlobalDefinition()");
Daniel Dunbar9c426522008-07-29 23:18:29 +0000807}
808
Chris Lattnerd4808922009-03-22 21:03:39 +0000809/// GetOrCreateLLVMFunction - If the specified mangled name is not in the
810/// module, create and return an llvm Function with the specified type. If there
811/// is something in the module with the specified name, return it potentially
812/// bitcasted to the right type.
813///
814/// If D is non-null, it specifies a decl that correspond to this. This is used
815/// to set the attributes on the function when it is first created.
John McCall7ec50432010-03-19 23:29:14 +0000816llvm::Constant *
817CodeGenModule::GetOrCreateLLVMFunction(llvm::StringRef MangledName,
818 const llvm::Type *Ty,
Anders Carlsson3c239482011-02-05 04:35:53 +0000819 GlobalDecl D, bool ForVTable) {
Chris Lattnera85d68e2009-03-21 09:25:43 +0000820 // Lookup the entry, lazily creating it if necessary.
John McCall7ec50432010-03-19 23:29:14 +0000821 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattnera85d68e2009-03-21 09:25:43 +0000822 if (Entry) {
Rafael Espindola2e42fec2010-03-04 18:17:24 +0000823 if (WeakRefReferences.count(Entry)) {
824 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl());
825 if (FD && !FD->hasAttr<WeakAttr>())
Anders Carlssonaf82f632010-03-23 04:31:31 +0000826 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola2e42fec2010-03-04 18:17:24 +0000827
828 WeakRefReferences.erase(Entry);
829 }
830
Chris Lattnera85d68e2009-03-21 09:25:43 +0000831 if (Entry->getType()->getElementType() == Ty)
832 return Entry;
Mike Stump11289f42009-09-09 15:08:12 +0000833
Chris Lattnera85d68e2009-03-21 09:25:43 +0000834 // Make sure the result is of the correct type.
Owen Anderson9793f0e2009-07-29 22:16:19 +0000835 const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
Owen Andersonade90fd2009-07-29 18:54:39 +0000836 return llvm::ConstantExpr::getBitCast(Entry, PTy);
Chris Lattnera85d68e2009-03-21 09:25:43 +0000837 }
Mike Stump11289f42009-09-09 15:08:12 +0000838
Eli Friedmancc522d92009-11-09 05:07:37 +0000839 // This function doesn't have a complete type (for example, the return
840 // type is an incomplete struct). Use a fake type instead, and make
841 // sure not to try to set attributes.
842 bool IsIncompleteFunction = false;
John McCalld06fb862010-04-28 00:00:30 +0000843
844 const llvm::FunctionType *FTy;
845 if (isa<llvm::FunctionType>(Ty)) {
846 FTy = cast<llvm::FunctionType>(Ty);
847 } else {
Benjamin Kramer1e188892011-01-22 12:15:57 +0000848 FTy = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false);
Eli Friedmancc522d92009-11-09 05:07:37 +0000849 IsIncompleteFunction = true;
850 }
Chris Lattner5c740f12010-06-30 19:14:05 +0000851
John McCalld06fb862010-04-28 00:00:30 +0000852 llvm::Function *F = llvm::Function::Create(FTy,
Eli Friedmancc522d92009-11-09 05:07:37 +0000853 llvm::Function::ExternalLinkage,
John McCall7ec50432010-03-19 23:29:14 +0000854 MangledName, &getModule());
855 assert(F->getName() == MangledName && "name was uniqued!");
Eli Friedmancc522d92009-11-09 05:07:37 +0000856 if (D.getDecl())
Anders Carlsson6710c532010-02-06 02:44:09 +0000857 SetFunctionAttributes(D, F, IsIncompleteFunction);
Eli Friedmancc522d92009-11-09 05:07:37 +0000858
Chris Lattner45470942009-03-21 09:44:56 +0000859 // This is the first use or definition of a mangled name. If there is a
860 // deferred decl with this name, remember that we need to emit it at the end
861 // of the file.
John McCall7ec50432010-03-19 23:29:14 +0000862 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner45470942009-03-21 09:44:56 +0000863 if (DDI != DeferredDecls.end()) {
864 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
865 // list, and remove it from DeferredDecls (since we don't need it anymore).
866 DeferredDeclsToEmit.push_back(DDI->second);
867 DeferredDecls.erase(DDI);
John McCall357d0f32010-12-15 04:00:32 +0000868
869 // Otherwise, there are cases we have to worry about where we're
870 // using a declaration for which we must emit a definition but where
871 // we might not find a top-level definition:
872 // - member functions defined inline in their classes
873 // - friend functions defined inline in some class
874 // - special member functions with implicit definitions
875 // If we ever change our AST traversal to walk into class methods,
876 // this will be unnecessary.
Anders Carlsson3c239482011-02-05 04:35:53 +0000877 //
878 // We also don't emit a definition for a function if it's going to be an entry
879 // in a vtable, unless it's already marked as used.
Rafael Espindolaaf5b92e2011-02-03 06:30:58 +0000880 } else if (getLangOptions().CPlusPlus && D.getDecl()) {
John McCall357d0f32010-12-15 04:00:32 +0000881 // Look for a declaration that's lexically in a record.
882 const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl());
883 do {
884 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
Anders Carlsson3c239482011-02-05 04:35:53 +0000885 if (FD->isImplicit() && !ForVTable) {
John McCall357d0f32010-12-15 04:00:32 +0000886 assert(FD->isUsed() && "Sema didn't mark implicit function as used!");
Douglas Gregor25756312011-02-09 02:03:05 +0000887 DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
John McCall357d0f32010-12-15 04:00:32 +0000888 break;
889 } else if (FD->isThisDeclarationADefinition()) {
Douglas Gregor25756312011-02-09 02:03:05 +0000890 DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
John McCall357d0f32010-12-15 04:00:32 +0000891 break;
892 }
Rafael Espindola70e040d2010-03-02 21:28:26 +0000893 }
John McCall357d0f32010-12-15 04:00:32 +0000894 FD = FD->getPreviousDeclaration();
895 } while (FD);
Chris Lattner45470942009-03-21 09:44:56 +0000896 }
Mike Stump11289f42009-09-09 15:08:12 +0000897
John McCalld06fb862010-04-28 00:00:30 +0000898 // Make sure the result is of the requested type.
899 if (!IsIncompleteFunction) {
900 assert(F->getType()->getElementType() == Ty);
901 return F;
902 }
903
904 const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
905 return llvm::ConstantExpr::getBitCast(F, PTy);
Chris Lattnera85d68e2009-03-21 09:25:43 +0000906}
907
Chris Lattnerd4808922009-03-22 21:03:39 +0000908/// GetAddrOfFunction - Return the address of the given function. If Ty is
909/// non-null, then this function will use the specified type if it has to
910/// create it (this occurs when we see a definition of the function).
Chris Lattnere0be0df2009-05-12 21:21:08 +0000911llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
Anders Carlsson3c239482011-02-05 04:35:53 +0000912 const llvm::Type *Ty,
913 bool ForVTable) {
Chris Lattnerd4808922009-03-22 21:03:39 +0000914 // If there was no specific requested type, just convert it now.
915 if (!Ty)
Anders Carlsson38988d72009-09-10 23:38:47 +0000916 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
Chris Lattner5c740f12010-06-30 19:14:05 +0000917
Anders Carlssonea836bc2010-06-22 16:16:50 +0000918 llvm::StringRef MangledName = getMangledName(GD);
Anders Carlsson3c239482011-02-05 04:35:53 +0000919 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable);
Chris Lattnerd4808922009-03-22 21:03:39 +0000920}
Eli Friedmanc18d9d52008-05-30 19:50:47 +0000921
Chris Lattnerd4808922009-03-22 21:03:39 +0000922/// CreateRuntimeFunction - Create a new runtime function with the specified
923/// type and name.
924llvm::Constant *
925CodeGenModule::CreateRuntimeFunction(const llvm::FunctionType *FTy,
John McCall7ec50432010-03-19 23:29:14 +0000926 llvm::StringRef Name) {
Anders Carlsson3c239482011-02-05 04:35:53 +0000927 return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false);
Chris Lattnerd4808922009-03-22 21:03:39 +0000928}
Daniel Dunbar9c426522008-07-29 23:18:29 +0000929
Eli Friedmanb095e152009-12-11 21:23:03 +0000930static bool DeclIsConstantGlobal(ASTContext &Context, const VarDecl *D) {
John McCall340aafa2010-02-08 21:46:50 +0000931 if (!D->getType().isConstant(Context) && !D->getType()->isReferenceType())
Eli Friedmanb095e152009-12-11 21:23:03 +0000932 return false;
933 if (Context.getLangOptions().CPlusPlus &&
934 Context.getBaseElementType(D->getType())->getAs<RecordType>()) {
935 // FIXME: We should do something fancier here!
936 return false;
937 }
938 return true;
939}
940
Chris Lattnerd4808922009-03-22 21:03:39 +0000941/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
942/// create and return an llvm GlobalVariable with the specified type. If there
943/// is something in the module with the specified name, return it potentially
944/// bitcasted to the right type.
945///
946/// If D is non-null, it specifies a decl that correspond to this. This is used
947/// to set the attributes on the global when it is first created.
John McCall7ec50432010-03-19 23:29:14 +0000948llvm::Constant *
949CodeGenModule::GetOrCreateLLVMGlobal(llvm::StringRef MangledName,
950 const llvm::PointerType *Ty,
Rafael Espindolad661a852011-01-18 21:07:57 +0000951 const VarDecl *D,
952 bool UnnamedAddr) {
Daniel Dunbar829e9882008-08-05 23:31:02 +0000953 // Lookup the entry, lazily creating it if necessary.
John McCall7ec50432010-03-19 23:29:14 +0000954 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner3bfce182009-03-21 08:03:33 +0000955 if (Entry) {
Rafael Espindola2e42fec2010-03-04 18:17:24 +0000956 if (WeakRefReferences.count(Entry)) {
957 if (D && !D->hasAttr<WeakAttr>())
Anders Carlssonaf82f632010-03-23 04:31:31 +0000958 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola2e42fec2010-03-04 18:17:24 +0000959
960 WeakRefReferences.erase(Entry);
961 }
962
Rafael Espindolad661a852011-01-18 21:07:57 +0000963 if (UnnamedAddr)
964 Entry->setUnnamedAddr(true);
965
Chris Lattnerd4808922009-03-22 21:03:39 +0000966 if (Entry->getType() == Ty)
Chris Lattner149927c2009-03-21 09:16:30 +0000967 return Entry;
Mike Stump11289f42009-09-09 15:08:12 +0000968
Chris Lattner3bfce182009-03-21 08:03:33 +0000969 // Make sure the result is of the correct type.
Owen Andersonade90fd2009-07-29 18:54:39 +0000970 return llvm::ConstantExpr::getBitCast(Entry, Ty);
Daniel Dunbardec798b2009-01-13 02:25:00 +0000971 }
Mike Stump11289f42009-09-09 15:08:12 +0000972
Chris Lattner45470942009-03-21 09:44:56 +0000973 // This is the first use or definition of a mangled name. If there is a
974 // deferred decl with this name, remember that we need to emit it at the end
975 // of the file.
John McCall7ec50432010-03-19 23:29:14 +0000976 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner45470942009-03-21 09:44:56 +0000977 if (DDI != DeferredDecls.end()) {
978 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
979 // list, and remove it from DeferredDecls (since we don't need it anymore).
980 DeferredDeclsToEmit.push_back(DDI->second);
981 DeferredDecls.erase(DDI);
982 }
Mike Stump11289f42009-09-09 15:08:12 +0000983
984 llvm::GlobalVariable *GV =
985 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
Chris Lattner3bfce182009-03-21 08:03:33 +0000986 llvm::GlobalValue::ExternalLinkage,
John McCall7ec50432010-03-19 23:29:14 +0000987 0, MangledName, 0,
Eli Friedman4f856742009-04-19 21:05:03 +0000988 false, Ty->getAddressSpace());
Chris Lattner3bfce182009-03-21 08:03:33 +0000989
990 // Handle things which are present even on external declarations.
Chris Lattnerd4808922009-03-22 21:03:39 +0000991 if (D) {
Mike Stump18bb9282009-05-16 07:57:57 +0000992 // FIXME: This code is overly simple and should be merged with other global
993 // handling.
Eli Friedmanb095e152009-12-11 21:23:03 +0000994 GV->setConstant(DeclIsConstantGlobal(Context, D));
Chris Lattner3bfce182009-03-21 08:03:33 +0000995
John McCall37bb6c92010-10-29 22:22:43 +0000996 // Set linkage and visibility in case we never see a definition.
John McCallc273f242010-10-30 11:50:40 +0000997 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility();
998 if (LV.linkage() != ExternalLinkage) {
John McCall83779672011-02-19 02:53:41 +0000999 // Don't set internal linkage on declarations.
John McCall37bb6c92010-10-29 22:22:43 +00001000 } else {
1001 if (D->hasAttr<DLLImportAttr>())
1002 GV->setLinkage(llvm::GlobalValue::DLLImportLinkage);
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00001003 else if (D->hasAttr<WeakAttr>() || D->isWeakImported())
John McCall37bb6c92010-10-29 22:22:43 +00001004 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Chris Lattner3bfce182009-03-21 08:03:33 +00001005
John McCallc273f242010-10-30 11:50:40 +00001006 // Set visibility on a declaration only if it's explicit.
1007 if (LV.visibilityExplicit())
1008 GV->setVisibility(GetLLVMVisibility(LV.visibility()));
John McCall37bb6c92010-10-29 22:22:43 +00001009 }
Eli Friedman4f856742009-04-19 21:05:03 +00001010
1011 GV->setThreadLocal(D->isThreadSpecified());
Chris Lattnerd4808922009-03-22 21:03:39 +00001012 }
Mike Stump11289f42009-09-09 15:08:12 +00001013
John McCall7ec50432010-03-19 23:29:14 +00001014 return GV;
Daniel Dunbar9c426522008-07-29 23:18:29 +00001015}
1016
Chris Lattnerd4808922009-03-22 21:03:39 +00001017
Anders Carlssonda80af32011-01-29 18:20:20 +00001018llvm::GlobalVariable *
1019CodeGenModule::CreateOrReplaceCXXRuntimeVariable(llvm::StringRef Name,
1020 const llvm::Type *Ty,
1021 llvm::GlobalValue::LinkageTypes Linkage) {
1022 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
1023 llvm::GlobalVariable *OldGV = 0;
1024
1025
1026 if (GV) {
1027 // Check if the variable has the right type.
1028 if (GV->getType()->getElementType() == Ty)
1029 return GV;
1030
1031 // Because C++ name mangling, the only way we can end up with an already
1032 // existing global with the same name is if it has been declared extern "C".
Anders Carlsson93be9a92011-01-29 18:25:07 +00001033 assert(GV->isDeclaration() && "Declaration has wrong type!");
Anders Carlssonda80af32011-01-29 18:20:20 +00001034 OldGV = GV;
1035 }
1036
1037 // Create a new variable.
1038 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
1039 Linkage, 0, Name);
1040
1041 if (OldGV) {
1042 // Replace occurrences of the old variable if needed.
1043 GV->takeName(OldGV);
1044
1045 if (!OldGV->use_empty()) {
1046 llvm::Constant *NewPtrForOldDecl =
1047 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
1048 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
1049 }
1050
1051 OldGV->eraseFromParent();
1052 }
1053
1054 return GV;
1055}
1056
Chris Lattnerd4808922009-03-22 21:03:39 +00001057/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
1058/// given global variable. If Ty is non-null and if the global doesn't exist,
1059/// then it will be greated with the specified type instead of whatever the
1060/// normal requested type would be.
1061llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
1062 const llvm::Type *Ty) {
1063 assert(D->hasGlobalStorage() && "Not a global variable");
1064 QualType ASTTy = D->getType();
1065 if (Ty == 0)
1066 Ty = getTypes().ConvertTypeForMem(ASTTy);
Mike Stump11289f42009-09-09 15:08:12 +00001067
1068 const llvm::PointerType *PTy =
Peter Collingbourne599cb8e2011-03-18 22:38:29 +00001069 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
John McCall7ec50432010-03-19 23:29:14 +00001070
Anders Carlssonea836bc2010-06-22 16:16:50 +00001071 llvm::StringRef MangledName = getMangledName(D);
John McCall7ec50432010-03-19 23:29:14 +00001072 return GetOrCreateLLVMGlobal(MangledName, PTy, D);
Chris Lattnerd4808922009-03-22 21:03:39 +00001073}
1074
John McCall31996342011-04-07 08:22:57 +00001075/// getAddrOfUnknownAnyDecl - Return an llvm::Constant for the address
1076/// of a global which was declared with unknown type. It is possible
1077/// for a VarDecl to end up getting resolved to have function type,
1078/// which complicates this substantially; on the other hand, these are
1079/// always external references, which does simplify the logic a lot.
1080llvm::Constant *
1081CodeGenModule::getAddrOfUnknownAnyDecl(const NamedDecl *decl, QualType type) {
1082 GlobalDecl global;
1083
1084 // FunctionDecls will always end up with function types, but
1085 // VarDecls can end up with them too.
1086 if (isa<FunctionDecl>(decl))
1087 global = GlobalDecl(cast<FunctionDecl>(decl));
1088 else
1089 global = GlobalDecl(cast<VarDecl>(decl));
1090 llvm::StringRef mangledName = getMangledName(global);
1091
1092 const llvm::Type *ty = getTypes().ConvertTypeForMem(type);
1093 const llvm::PointerType *pty =
1094 llvm::PointerType::get(ty, getContext().getTargetAddressSpace(type));
1095
1096
1097 // Check for an existing global value with this name.
1098 llvm::GlobalValue *entry = GetGlobalValue(mangledName);
1099 if (entry)
1100 return llvm::ConstantExpr::getBitCast(entry, pty);
1101
1102 // If we're creating something with function type, go ahead and
1103 // create a function.
1104 if (const llvm::FunctionType *fnty = dyn_cast<llvm::FunctionType>(ty)) {
1105 llvm::Function *fn = llvm::Function::Create(fnty,
1106 llvm::Function::ExternalLinkage,
1107 mangledName, &getModule());
1108 return fn;
1109
1110 // Otherwise, make a global variable.
1111 } else {
1112 llvm::GlobalVariable *var
1113 = new llvm::GlobalVariable(getModule(), ty, false,
1114 llvm::GlobalValue::ExternalLinkage,
1115 0, mangledName, 0,
1116 false, pty->getAddressSpace());
1117 if (isa<VarDecl>(decl) && cast<VarDecl>(decl)->isThreadSpecified())
1118 var->setThreadLocal(true);
1119 return var;
1120 }
1121}
1122
Chris Lattnerd4808922009-03-22 21:03:39 +00001123/// CreateRuntimeVariable - Create a new runtime global variable with the
1124/// specified type and name.
1125llvm::Constant *
1126CodeGenModule::CreateRuntimeVariable(const llvm::Type *Ty,
John McCall7ec50432010-03-19 23:29:14 +00001127 llvm::StringRef Name) {
John McCall31996342011-04-07 08:22:57 +00001128 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0,
Rafael Espindolad661a852011-01-18 21:07:57 +00001129 true);
Chris Lattnerd4808922009-03-22 21:03:39 +00001130}
1131
Daniel Dunbar7dd749e2009-04-15 22:08:45 +00001132void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1133 assert(!D->getInit() && "Cannot emit definite definitions here!");
1134
Douglas Gregorfa9ab532009-04-21 19:28:58 +00001135 if (MayDeferGeneration(D)) {
1136 // If we have not seen a reference to this variable yet, place it
1137 // into the deferred declarations table to be emitted if needed
1138 // later.
Anders Carlssonea836bc2010-06-22 16:16:50 +00001139 llvm::StringRef MangledName = getMangledName(D);
John McCall7ec50432010-03-19 23:29:14 +00001140 if (!GetGlobalValue(MangledName)) {
Anders Carlssonecf9bf02009-09-10 23:43:36 +00001141 DeferredDecls[MangledName] = D;
Daniel Dunbar7dd749e2009-04-15 22:08:45 +00001142 return;
Douglas Gregorfa9ab532009-04-21 19:28:58 +00001143 }
1144 }
1145
1146 // The tentative definition is the only definition.
Daniel Dunbar7dd749e2009-04-15 22:08:45 +00001147 EmitGlobalVarDefinition(D);
1148}
1149
Douglas Gregor88d292c2010-05-13 16:44:06 +00001150void CodeGenModule::EmitVTable(CXXRecordDecl *Class, bool DefinitionRequired) {
1151 if (DefinitionRequired)
1152 getVTables().GenerateClassData(getVTableLinkage(Class), Class);
1153}
1154
Douglas Gregorccecc1b2010-01-06 20:27:16 +00001155llvm::GlobalVariable::LinkageTypes
Anders Carlsson11e51402010-04-17 20:15:18 +00001156CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
Douglas Gregor2a34df32010-01-06 22:00:56 +00001157 if (RD->isInAnonymousNamespace() || !RD->hasLinkage())
1158 return llvm::GlobalVariable::InternalLinkage;
1159
1160 if (const CXXMethodDecl *KeyFunction
1161 = RD->getASTContext().getKeyFunction(RD)) {
1162 // If this class has a key function, use that to determine the linkage of
1163 // the vtable.
Douglas Gregorccecc1b2010-01-06 20:27:16 +00001164 const FunctionDecl *Def = 0;
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00001165 if (KeyFunction->hasBody(Def))
Douglas Gregorccecc1b2010-01-06 20:27:16 +00001166 KeyFunction = cast<CXXMethodDecl>(Def);
Douglas Gregor2a34df32010-01-06 22:00:56 +00001167
Douglas Gregorccecc1b2010-01-06 20:27:16 +00001168 switch (KeyFunction->getTemplateSpecializationKind()) {
1169 case TSK_Undeclared:
1170 case TSK_ExplicitSpecialization:
Anders Carlssona03f3a82011-01-30 20:45:54 +00001171 // When compiling with optimizations turned on, we emit all vtables,
1172 // even if the key function is not defined in the current translation
1173 // unit. If this is the case, use available_externally linkage.
1174 if (!Def && CodeGenOpts.OptimizationLevel)
1175 return llvm::GlobalVariable::AvailableExternallyLinkage;
1176
Douglas Gregorccecc1b2010-01-06 20:27:16 +00001177 if (KeyFunction->isInlined())
Fariborz Jahanianf7f04452011-02-04 00:01:24 +00001178 return !Context.getLangOptions().AppleKext ?
1179 llvm::GlobalVariable::LinkOnceODRLinkage :
1180 llvm::Function::InternalLinkage;
Douglas Gregorccecc1b2010-01-06 20:27:16 +00001181
1182 return llvm::GlobalVariable::ExternalLinkage;
1183
1184 case TSK_ImplicitInstantiation:
Fariborz Jahanianf7f04452011-02-04 00:01:24 +00001185 return !Context.getLangOptions().AppleKext ?
1186 llvm::GlobalVariable::LinkOnceODRLinkage :
1187 llvm::Function::InternalLinkage;
Anders Carlsson571e2ad2011-01-24 00:46:19 +00001188
Douglas Gregorccecc1b2010-01-06 20:27:16 +00001189 case TSK_ExplicitInstantiationDefinition:
Fariborz Jahanianf7f04452011-02-04 00:01:24 +00001190 return !Context.getLangOptions().AppleKext ?
1191 llvm::GlobalVariable::WeakODRLinkage :
1192 llvm::Function::InternalLinkage;
Anders Carlsson571e2ad2011-01-24 00:46:19 +00001193
Douglas Gregorccecc1b2010-01-06 20:27:16 +00001194 case TSK_ExplicitInstantiationDeclaration:
1195 // FIXME: Use available_externally linkage. However, this currently
1196 // breaks LLVM's build due to undefined symbols.
1197 // return llvm::GlobalVariable::AvailableExternallyLinkage;
Fariborz Jahanianf7f04452011-02-04 00:01:24 +00001198 return !Context.getLangOptions().AppleKext ?
1199 llvm::GlobalVariable::LinkOnceODRLinkage :
1200 llvm::Function::InternalLinkage;
Douglas Gregorccecc1b2010-01-06 20:27:16 +00001201 }
Douglas Gregor2a34df32010-01-06 22:00:56 +00001202 }
1203
Fariborz Jahaniane28342c2011-02-04 00:32:39 +00001204 if (Context.getLangOptions().AppleKext)
1205 return llvm::Function::InternalLinkage;
1206
Douglas Gregor2a34df32010-01-06 22:00:56 +00001207 switch (RD->getTemplateSpecializationKind()) {
1208 case TSK_Undeclared:
1209 case TSK_ExplicitSpecialization:
1210 case TSK_ImplicitInstantiation:
Douglas Gregor2a34df32010-01-06 22:00:56 +00001211 // FIXME: Use available_externally linkage. However, this currently
1212 // breaks LLVM's build due to undefined symbols.
1213 // return llvm::GlobalVariable::AvailableExternallyLinkage;
Fariborz Jahanianf7f04452011-02-04 00:01:24 +00001214 case TSK_ExplicitInstantiationDeclaration:
Fariborz Jahaniane28342c2011-02-04 00:32:39 +00001215 return llvm::GlobalVariable::LinkOnceODRLinkage;
Fariborz Jahanianf7f04452011-02-04 00:01:24 +00001216
1217 case TSK_ExplicitInstantiationDefinition:
Fariborz Jahaniane28342c2011-02-04 00:32:39 +00001218 return llvm::GlobalVariable::WeakODRLinkage;
Douglas Gregorccecc1b2010-01-06 20:27:16 +00001219 }
1220
1221 // Silence GCC warning.
Fariborz Jahaniane28342c2011-02-04 00:32:39 +00001222 return llvm::GlobalVariable::LinkOnceODRLinkage;
Douglas Gregorccecc1b2010-01-06 20:27:16 +00001223}
1224
Ken Dyck98ca7942010-01-26 13:48:07 +00001225CharUnits CodeGenModule::GetTargetTypeStoreSize(const llvm::Type *Ty) const {
Ken Dyck9a648692011-01-18 02:01:14 +00001226 return Context.toCharUnitsFromBits(
1227 TheTargetData.getTypeStoreSizeInBits(Ty));
Ken Dyck98ca7942010-01-26 13:48:07 +00001228}
1229
Daniel Dunbar9c426522008-07-29 23:18:29 +00001230void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
Chris Lattner9d3b0e02007-07-14 00:23:28 +00001231 llvm::Constant *Init = 0;
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001232 QualType ASTTy = D->getType();
Eli Friedman5866fe32010-01-08 00:50:11 +00001233 bool NonConstInit = false;
Mike Stump11289f42009-09-09 15:08:12 +00001234
Sebastian Redl5ca79842010-02-01 20:16:42 +00001235 const Expr *InitExpr = D->getAnyInitializer();
Anders Carlssonca4a5452010-01-26 17:43:42 +00001236
1237 if (!InitExpr) {
Eli Friedman6859a1b2008-05-30 20:39:54 +00001238 // This is a tentative definition; tentative definitions are
Daniel Dunbar7dd749e2009-04-15 22:08:45 +00001239 // implicitly initialized with { 0 }.
1240 //
1241 // Note that tentative definitions are only emitted at the end of
1242 // a translation unit, so they should never have incomplete
1243 // type. In addition, EmitTentativeDefinition makes sure that we
1244 // never attempt to emit a tentative definition if a real one
1245 // exists. A use may still exists, however, so we still may need
1246 // to do a RAUW.
1247 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
Anders Carlssonf18318c2009-08-02 21:18:22 +00001248 Init = EmitNullConstant(D->getType());
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001249 } else {
Douglas Gregord450f062010-05-05 20:15:55 +00001250 Init = EmitConstantExpr(InitExpr, D->getType());
Eli Friedman719ed1a2009-02-20 01:18:21 +00001251 if (!Init) {
Anders Carlssonca4a5452010-01-26 17:43:42 +00001252 QualType T = InitExpr->getType();
Douglas Gregord450f062010-05-05 20:15:55 +00001253 if (D->getType()->isReferenceType())
1254 T = D->getType();
1255
Anders Carlssonb8be93f2009-08-08 23:24:23 +00001256 if (getLangOptions().CPlusPlus) {
Anders Carlssonb8be93f2009-08-08 23:24:23 +00001257 Init = EmitNullConstant(T);
Eli Friedman5866fe32010-01-08 00:50:11 +00001258 NonConstInit = true;
Anders Carlssonb8be93f2009-08-08 23:24:23 +00001259 } else {
1260 ErrorUnsupported(D, "static initializer");
1261 Init = llvm::UndefValue::get(getTypes().ConvertType(T));
1262 }
John McCall70013b62010-07-15 23:40:35 +00001263 } else {
1264 // We don't need an initializer, so remove the entry for the delayed
1265 // initializer position (just in case this entry was delayed).
1266 if (getLangOptions().CPlusPlus)
1267 DelayedCXXInitPosition.erase(D);
Eli Friedman719ed1a2009-02-20 01:18:21 +00001268 }
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001269 }
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001270
Chris Lattner64c55932009-03-21 08:13:05 +00001271 const llvm::Type* InitType = Init->getType();
Chris Lattner149927c2009-03-21 09:16:30 +00001272 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
Mike Stump11289f42009-09-09 15:08:12 +00001273
Chris Lattner149927c2009-03-21 09:16:30 +00001274 // Strip off a bitcast if we got one back.
1275 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
Chris Lattneraa64ca22009-07-16 16:48:25 +00001276 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
1277 // all zero index gep.
1278 CE->getOpcode() == llvm::Instruction::GetElementPtr);
Chris Lattner149927c2009-03-21 09:16:30 +00001279 Entry = CE->getOperand(0);
1280 }
Mike Stump11289f42009-09-09 15:08:12 +00001281
Chris Lattner149927c2009-03-21 09:16:30 +00001282 // Entry is now either a Function or GlobalVariable.
1283 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
Mike Stump11289f42009-09-09 15:08:12 +00001284
Chris Lattner149927c2009-03-21 09:16:30 +00001285 // We have a definition after a declaration with the wrong type.
1286 // We must make a new GlobalVariable* and update everything that used OldGV
1287 // (a declaration or tentative definition) with the new GlobalVariable*
1288 // (which will be a definition).
1289 //
1290 // This happens if there is a prototype for a global (e.g.
1291 // "extern int x[];") and then a definition of a different type (e.g.
1292 // "int x[10];"). This also happens when an initializer has a different type
1293 // from the type of the global (this happens with unions).
Chris Lattner149927c2009-03-21 09:16:30 +00001294 if (GV == 0 ||
1295 GV->getType()->getElementType() != InitType ||
Peter Collingbourne599cb8e2011-03-18 22:38:29 +00001296 GV->getType()->getAddressSpace() !=
1297 getContext().getTargetAddressSpace(ASTTy)) {
Mike Stump11289f42009-09-09 15:08:12 +00001298
John McCall7ec50432010-03-19 23:29:14 +00001299 // Move the old entry aside so that we'll create a new one.
1300 Entry->setName(llvm::StringRef());
Daniel Dunbarb2f4cdb2009-02-19 05:36:41 +00001301
Chris Lattner149927c2009-03-21 09:16:30 +00001302 // Make a new global with the correct type, this is now guaranteed to work.
1303 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
Chris Lattnera85d68e2009-03-21 09:25:43 +00001304
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001305 // Replace all uses of the old global with the new global
Mike Stump11289f42009-09-09 15:08:12 +00001306 llvm::Constant *NewPtrForOldDecl =
Owen Andersonade90fd2009-07-29 18:54:39 +00001307 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
Chris Lattner149927c2009-03-21 09:16:30 +00001308 Entry->replaceAllUsesWith(NewPtrForOldDecl);
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001309
1310 // Erase the old global, since it is no longer used.
Chris Lattner149927c2009-03-21 09:16:30 +00001311 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
Chris Lattner9d3b0e02007-07-14 00:23:28 +00001312 }
Devang Patel19c2b9a2007-10-26 16:31:40 +00001313
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00001314 if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) {
Nate Begemanfaae0812008-04-19 04:17:09 +00001315 SourceManager &SM = Context.getSourceManager();
1316 AddAnnotation(EmitAnnotateAttr(GV, AA,
Chris Lattner8a425862009-01-16 07:36:28 +00001317 SM.getInstantiationLineNumber(D->getLocation())));
Nate Begemanfaae0812008-04-19 04:17:09 +00001318 }
1319
Chris Lattnerd14bfa92007-07-13 05:13:43 +00001320 GV->setInitializer(Init);
Chris Lattnerf49573d2009-08-05 05:20:29 +00001321
1322 // If it is safe to mark the global 'constant', do so now.
1323 GV->setConstant(false);
Eli Friedman5866fe32010-01-08 00:50:11 +00001324 if (!NonConstInit && DeclIsConstantGlobal(Context, D))
Chris Lattnerf49573d2009-08-05 05:20:29 +00001325 GV->setConstant(true);
Mike Stump11289f42009-09-09 15:08:12 +00001326
Ken Dyck160146e2010-01-27 17:10:57 +00001327 GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
Fariborz Jahanian1518a5ec2010-10-27 16:21:54 +00001328
Chris Lattnerd14bfa92007-07-13 05:13:43 +00001329 // Set the llvm linkage type as appropriate.
Fariborz Jahanian1518a5ec2010-10-27 16:21:54 +00001330 llvm::GlobalValue::LinkageTypes Linkage =
1331 GetLLVMLinkageVarDefinition(D, GV);
1332 GV->setLinkage(Linkage);
1333 if (Linkage == llvm::GlobalVariable::CommonLinkage)
Chris Lattnerf49573d2009-08-05 05:20:29 +00001334 // common vars aren't constant even if declared const.
1335 GV->setConstant(false);
Daniel Dunbard272cca2009-04-10 20:26:50 +00001336
Daniel Dunbar38932572009-04-14 08:05:55 +00001337 SetCommonAttributes(D, GV);
Daniel Dunbarf5f359f2009-04-14 06:00:08 +00001338
John McCallcdf7ef52010-11-06 09:44:32 +00001339 // Emit the initializer function if necessary.
1340 if (NonConstInit)
1341 EmitCXXGlobalVarDeclInitFunc(D, GV);
1342
Sanjiv Gupta158143a2008-06-05 08:59:10 +00001343 // Emit global variable debug information.
Devang Pateld6ffebb2011-03-07 18:45:56 +00001344 if (CGDebugInfo *DI = getModuleDebugInfo()) {
Daniel Dunbarb9fd9022008-10-17 16:15:48 +00001345 DI->setLocation(D->getLocation());
Sanjiv Gupta158143a2008-06-05 08:59:10 +00001346 DI->EmitGlobalVariable(GV, D);
1347 }
Chris Lattnerd14bfa92007-07-13 05:13:43 +00001348}
Chris Lattner09153c02007-06-22 18:48:09 +00001349
Fariborz Jahanian1518a5ec2010-10-27 16:21:54 +00001350llvm::GlobalValue::LinkageTypes
1351CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D,
1352 llvm::GlobalVariable *GV) {
1353 GVALinkage Linkage = getContext().GetGVALinkageForVariable(D);
1354 if (Linkage == GVA_Internal)
1355 return llvm::Function::InternalLinkage;
1356 else if (D->hasAttr<DLLImportAttr>())
1357 return llvm::Function::DLLImportLinkage;
1358 else if (D->hasAttr<DLLExportAttr>())
1359 return llvm::Function::DLLExportLinkage;
1360 else if (D->hasAttr<WeakAttr>()) {
1361 if (GV->isConstant())
1362 return llvm::GlobalVariable::WeakODRLinkage;
1363 else
1364 return llvm::GlobalVariable::WeakAnyLinkage;
1365 } else if (Linkage == GVA_TemplateInstantiation ||
1366 Linkage == GVA_ExplicitTemplateInstantiation)
1367 // FIXME: It seems like we can provide more specific linkage here
1368 // (LinkOnceODR, WeakODR).
1369 return llvm::GlobalVariable::WeakAnyLinkage;
Eric Christopher8a2ee392010-12-02 02:45:55 +00001370 else if (!getLangOptions().CPlusPlus &&
1371 ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) ||
1372 D->getAttr<CommonAttr>()) &&
Fariborz Jahanian1518a5ec2010-10-27 16:21:54 +00001373 !D->hasExternalStorage() && !D->getInit() &&
1374 !D->getAttr<SectionAttr>() && !D->isThreadSpecified()) {
1375 // Thread local vars aren't considered common linkage.
1376 return llvm::GlobalVariable::CommonLinkage;
1377 }
1378 return llvm::GlobalVariable::ExternalLinkage;
1379}
1380
Chris Lattner36797ab2009-05-05 06:16:31 +00001381/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
1382/// implement a function with no prototype, e.g. "int foo() {}". If there are
1383/// existing call uses of the old function in the module, this adjusts them to
1384/// call the new function directly.
1385///
1386/// This is not just a cleanup: the always_inline pass requires direct calls to
1387/// functions to be able to inline them. If there is a bitcast in the way, it
1388/// won't inline them. Instcombine normally deletes these calls, but it isn't
1389/// run at -O0.
1390static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
1391 llvm::Function *NewFn) {
1392 // If we're redefining a global as a function, don't transform it.
1393 llvm::Function *OldFn = dyn_cast<llvm::Function>(Old);
1394 if (OldFn == 0) return;
Mike Stump11289f42009-09-09 15:08:12 +00001395
Chris Lattner36797ab2009-05-05 06:16:31 +00001396 const llvm::Type *NewRetTy = NewFn->getReturnType();
1397 llvm::SmallVector<llvm::Value*, 4> ArgList;
1398
1399 for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end();
Benjamin Kramer2e8ca0b2010-04-10 11:02:40 +00001400 UI != E; ) {
Chris Lattner36797ab2009-05-05 06:16:31 +00001401 // TODO: Do invokes ever occur in C code? If so, we should handle them too.
Benjamin Kramer2e8ca0b2010-04-10 11:02:40 +00001402 llvm::Value::use_iterator I = UI++; // Increment before the CI is erased.
1403 llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*I);
Gabor Greif79ac9ed2010-07-28 09:19:33 +00001404 if (!CI) continue; // FIXME: when we allow Invoke, just do CallSite CS(*I)
Gabor Greifd394aec2010-04-10 03:45:50 +00001405 llvm::CallSite CS(CI);
Benjamin Kramer2e8ca0b2010-04-10 11:02:40 +00001406 if (!CI || !CS.isCallee(I)) continue;
Mike Stump11289f42009-09-09 15:08:12 +00001407
Chris Lattner36797ab2009-05-05 06:16:31 +00001408 // If the return types don't match exactly, and if the call isn't dead, then
1409 // we can't transform this call.
1410 if (CI->getType() != NewRetTy && !CI->use_empty())
1411 continue;
1412
1413 // If the function was passed too few arguments, don't transform. If extra
1414 // arguments were passed, we silently drop them. If any of the types
1415 // mismatch, we don't transform.
1416 unsigned ArgNo = 0;
1417 bool DontTransform = false;
1418 for (llvm::Function::arg_iterator AI = NewFn->arg_begin(),
1419 E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) {
Gabor Greifd394aec2010-04-10 03:45:50 +00001420 if (CS.arg_size() == ArgNo ||
1421 CS.getArgument(ArgNo)->getType() != AI->getType()) {
Chris Lattner36797ab2009-05-05 06:16:31 +00001422 DontTransform = true;
1423 break;
1424 }
1425 }
1426 if (DontTransform)
1427 continue;
Mike Stump11289f42009-09-09 15:08:12 +00001428
Chris Lattner36797ab2009-05-05 06:16:31 +00001429 // Okay, we can transform this. Create the new call instruction and copy
1430 // over the required information.
Gabor Greifd0ef1342010-04-10 02:56:12 +00001431 ArgList.append(CS.arg_begin(), CS.arg_begin() + ArgNo);
Chris Lattner36797ab2009-05-05 06:16:31 +00001432 llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList.begin(),
1433 ArgList.end(), "", CI);
1434 ArgList.clear();
Benjamin Kramerdde0fee2009-10-05 13:47:21 +00001435 if (!NewCall->getType()->isVoidTy())
Chris Lattner36797ab2009-05-05 06:16:31 +00001436 NewCall->takeName(CI);
Chris Lattner36797ab2009-05-05 06:16:31 +00001437 NewCall->setAttributes(CI->getAttributes());
Daniel Dunbar0ef34792009-09-12 00:59:20 +00001438 NewCall->setCallingConv(CI->getCallingConv());
Chris Lattner36797ab2009-05-05 06:16:31 +00001439
1440 // Finally, remove the old call, replacing any uses with the new one.
Chris Lattner734351d2009-10-14 05:49:21 +00001441 if (!CI->use_empty())
1442 CI->replaceAllUsesWith(NewCall);
Devang Patel74684892009-10-13 17:02:04 +00001443
Chris Lattnere675d0f2010-04-01 06:31:43 +00001444 // Copy debug location attached to CI.
1445 if (!CI->getDebugLoc().isUnknown())
1446 NewCall->setDebugLoc(CI->getDebugLoc());
Chris Lattner36797ab2009-05-05 06:16:31 +00001447 CI->eraseFromParent();
1448 }
1449}
1450
Daniel Dunbar9c426522008-07-29 23:18:29 +00001451
Chris Lattnere0be0df2009-05-12 21:21:08 +00001452void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
Chris Lattnere0be0df2009-05-12 21:21:08 +00001453 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
John McCalla738c252011-03-09 04:27:21 +00001454
John McCall46288ef2011-03-09 08:12:35 +00001455 // Compute the function info and LLVM type.
John McCalla738c252011-03-09 04:27:21 +00001456 const CGFunctionInfo &FI = getTypes().getFunctionInfo(GD);
John McCall46288ef2011-03-09 08:12:35 +00001457 bool variadic = false;
1458 if (const FunctionProtoType *fpt = D->getType()->getAs<FunctionProtoType>())
1459 variadic = fpt->isVariadic();
1460 const llvm::FunctionType *Ty = getTypes().GetFunctionType(FI, variadic, false);
John McCalla738c252011-03-09 04:27:21 +00001461
Chris Lattnereb7466d2009-05-12 20:58:15 +00001462 // Get or create the prototype for the function.
Chris Lattnere0be0df2009-05-12 21:21:08 +00001463 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
Mike Stump11289f42009-09-09 15:08:12 +00001464
Chris Lattnera85d68e2009-03-21 09:25:43 +00001465 // Strip off a bitcast if we got one back.
1466 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
1467 assert(CE->getOpcode() == llvm::Instruction::BitCast);
1468 Entry = CE->getOperand(0);
1469 }
Mike Stump11289f42009-09-09 15:08:12 +00001470
1471
Chris Lattnera85d68e2009-03-21 09:25:43 +00001472 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
Chris Lattner36797ab2009-05-05 06:16:31 +00001473 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
Mike Stump11289f42009-09-09 15:08:12 +00001474
Daniel Dunbar99d28352009-03-09 23:53:08 +00001475 // If the types mismatch then we have to rewrite the definition.
Chris Lattner36797ab2009-05-05 06:16:31 +00001476 assert(OldFn->isDeclaration() &&
Chris Lattnera85d68e2009-03-21 09:25:43 +00001477 "Shouldn't replace non-declaration");
Chris Lattner832323e2009-03-21 08:53:37 +00001478
Chris Lattner5eaee562009-03-21 08:38:50 +00001479 // F is the Function* for the one with the wrong type, we must make a new
1480 // Function* and update everything that used F (a declaration) with the new
1481 // Function* (which will be a definition).
1482 //
1483 // This happens if there is a prototype for a function
1484 // (e.g. "int f()") and then a definition of a different type
John McCall7ec50432010-03-19 23:29:14 +00001485 // (e.g. "int f(int x)"). Move the old function aside so that it
1486 // doesn't interfere with GetAddrOfFunction.
1487 OldFn->setName(llvm::StringRef());
Chris Lattnere0be0df2009-05-12 21:21:08 +00001488 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
Mike Stump11289f42009-09-09 15:08:12 +00001489
Chris Lattner36797ab2009-05-05 06:16:31 +00001490 // If this is an implementation of a function without a prototype, try to
1491 // replace any existing uses of the function (which may be calls) with uses
1492 // of the new function
Chris Lattnereb7466d2009-05-12 20:58:15 +00001493 if (D->getType()->isFunctionNoProtoType()) {
Chris Lattner36797ab2009-05-05 06:16:31 +00001494 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
Chris Lattnereb7466d2009-05-12 20:58:15 +00001495 OldFn->removeDeadConstantUsers();
1496 }
Mike Stump11289f42009-09-09 15:08:12 +00001497
Chris Lattner5eaee562009-03-21 08:38:50 +00001498 // Replace uses of F with the Function we will endow with a body.
Chris Lattner36797ab2009-05-05 06:16:31 +00001499 if (!Entry->use_empty()) {
Mike Stump11289f42009-09-09 15:08:12 +00001500 llvm::Constant *NewPtrForOldDecl =
Owen Andersonade90fd2009-07-29 18:54:39 +00001501 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
Chris Lattner36797ab2009-05-05 06:16:31 +00001502 Entry->replaceAllUsesWith(NewPtrForOldDecl);
1503 }
Mike Stump11289f42009-09-09 15:08:12 +00001504
Chris Lattner5eaee562009-03-21 08:38:50 +00001505 // Ok, delete the old function now, which is dead.
Chris Lattner36797ab2009-05-05 06:16:31 +00001506 OldFn->eraseFromParent();
Mike Stump11289f42009-09-09 15:08:12 +00001507
Chris Lattnera85d68e2009-03-21 09:25:43 +00001508 Entry = NewFn;
Daniel Dunbar9c426522008-07-29 23:18:29 +00001509 }
Mike Stump11289f42009-09-09 15:08:12 +00001510
John McCall8e7cb6d2010-11-02 21:04:24 +00001511 // We need to set linkage and visibility on the function before
1512 // generating code for it because various parts of IR generation
1513 // want to propagate this information down (e.g. to local static
1514 // declarations).
Chris Lattnera85d68e2009-03-21 09:25:43 +00001515 llvm::Function *Fn = cast<llvm::Function>(Entry);
John McCall7cb02202010-05-25 04:30:21 +00001516 setFunctionLinkage(D, Fn);
Daniel Dunbar9c426522008-07-29 23:18:29 +00001517
John McCall8e7cb6d2010-11-02 21:04:24 +00001518 // FIXME: this is redundant with part of SetFunctionDefinitionAttributes
Anders Carlssonc6a47892011-01-29 19:39:23 +00001519 setGlobalVisibility(Fn, D);
John McCall8e7cb6d2010-11-02 21:04:24 +00001520
John McCalla738c252011-03-09 04:27:21 +00001521 CodeGenFunction(*this).GenerateCode(D, Fn, FI);
Daniel Dunbar74aa7e12008-08-01 00:01:51 +00001522
Daniel Dunbar38932572009-04-14 08:05:55 +00001523 SetFunctionDefinitionAttributes(D, Fn);
1524 SetLLVMFunctionAttributesForDefinition(D, Fn);
Mike Stump11289f42009-09-09 15:08:12 +00001525
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00001526 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
Daniel Dunbar0beedc12008-09-08 23:44:31 +00001527 AddGlobalCtor(Fn, CA->getPriority());
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00001528 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
Daniel Dunbar0beedc12008-09-08 23:44:31 +00001529 AddGlobalDtor(Fn, DA->getPriority());
Daniel Dunbar9c426522008-07-29 23:18:29 +00001530}
1531
John McCall7ec50432010-03-19 23:29:14 +00001532void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
1533 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00001534 const AliasAttr *AA = D->getAttr<AliasAttr>();
Chris Lattner54041692009-03-22 21:47:11 +00001535 assert(AA && "Not an alias?");
1536
Anders Carlssonea836bc2010-06-22 16:16:50 +00001537 llvm::StringRef MangledName = getMangledName(GD);
Mike Stump11289f42009-09-09 15:08:12 +00001538
John McCall7ec50432010-03-19 23:29:14 +00001539 // If there is a definition in the module, then it wins over the alias.
1540 // This is dubious, but allow it to be safe. Just ignore the alias.
1541 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1542 if (Entry && !Entry->isDeclaration())
1543 return;
1544
1545 const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
Chris Lattner54041692009-03-22 21:47:11 +00001546
1547 // Create a reference to the named value. This ensures that it is emitted
1548 // if a deferred decl.
1549 llvm::Constant *Aliasee;
1550 if (isa<llvm::FunctionType>(DeclTy))
Anders Carlsson3c239482011-02-05 04:35:53 +00001551 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl(),
1552 /*ForVTable=*/false);
Chris Lattner54041692009-03-22 21:47:11 +00001553 else
John McCall7ec50432010-03-19 23:29:14 +00001554 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Owen Anderson9793f0e2009-07-29 22:16:19 +00001555 llvm::PointerType::getUnqual(DeclTy), 0);
Chris Lattner54041692009-03-22 21:47:11 +00001556
1557 // Create the new alias itself, but don't set a name yet.
Mike Stump11289f42009-09-09 15:08:12 +00001558 llvm::GlobalValue *GA =
Chris Lattner54041692009-03-22 21:47:11 +00001559 new llvm::GlobalAlias(Aliasee->getType(),
1560 llvm::Function::ExternalLinkage,
1561 "", Aliasee, &getModule());
Mike Stump11289f42009-09-09 15:08:12 +00001562
Chris Lattner54041692009-03-22 21:47:11 +00001563 if (Entry) {
John McCall7ec50432010-03-19 23:29:14 +00001564 assert(Entry->isDeclaration());
1565
Chris Lattner54041692009-03-22 21:47:11 +00001566 // If there is a declaration in the module, then we had an extern followed
1567 // by the alias, as in:
1568 // extern int test6();
1569 // ...
1570 // int test6() __attribute__((alias("test7")));
1571 //
1572 // Remove it and replace uses of it with the alias.
John McCall7ec50432010-03-19 23:29:14 +00001573 GA->takeName(Entry);
Mike Stump11289f42009-09-09 15:08:12 +00001574
Owen Andersonade90fd2009-07-29 18:54:39 +00001575 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
Chris Lattner54041692009-03-22 21:47:11 +00001576 Entry->getType()));
Chris Lattner54041692009-03-22 21:47:11 +00001577 Entry->eraseFromParent();
John McCall7ec50432010-03-19 23:29:14 +00001578 } else {
Anders Carlssonea836bc2010-06-22 16:16:50 +00001579 GA->setName(MangledName);
Chris Lattner54041692009-03-22 21:47:11 +00001580 }
Mike Stump11289f42009-09-09 15:08:12 +00001581
Daniel Dunbar38932572009-04-14 08:05:55 +00001582 // Set attributes which are particular to an alias; this is a
1583 // specialization of the attributes which may be set on a global
1584 // variable/function.
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00001585 if (D->hasAttr<DLLExportAttr>()) {
Daniel Dunbar38932572009-04-14 08:05:55 +00001586 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1587 // The dllexport attribute is ignored for undefined symbols.
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00001588 if (FD->hasBody())
Daniel Dunbar38932572009-04-14 08:05:55 +00001589 GA->setLinkage(llvm::Function::DLLExportLinkage);
1590 } else {
1591 GA->setLinkage(llvm::Function::DLLExportLinkage);
1592 }
Mike Stump11289f42009-09-09 15:08:12 +00001593 } else if (D->hasAttr<WeakAttr>() ||
Rafael Espindolac18086a2010-02-23 22:00:30 +00001594 D->hasAttr<WeakRefAttr>() ||
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00001595 D->isWeakImported()) {
Daniel Dunbar38932572009-04-14 08:05:55 +00001596 GA->setLinkage(llvm::Function::WeakAnyLinkage);
1597 }
1598
1599 SetCommonAttributes(D, GA);
Chris Lattner54041692009-03-22 21:47:11 +00001600}
1601
Chris Lattnere64911a2009-03-22 21:56:56 +00001602/// getBuiltinLibFunction - Given a builtin id for a function like
1603/// "__builtin_fabsf", return a Function* for "fabsf".
Daniel Dunbarff0553e2009-09-14 04:33:21 +00001604llvm::Value *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD,
1605 unsigned BuiltinID) {
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001606 assert((Context.BuiltinInfo.isLibFunction(BuiltinID) ||
Mike Stump11289f42009-09-09 15:08:12 +00001607 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) &&
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001608 "isn't a lib fn");
Mike Stump11289f42009-09-09 15:08:12 +00001609
Douglas Gregorb9063fc2009-02-13 23:20:09 +00001610 // Get the name, skip over the __builtin_ prefix (if necessary).
1611 const char *Name = Context.BuiltinInfo.GetName(BuiltinID);
1612 if (Context.BuiltinInfo.isLibFunction(BuiltinID))
1613 Name += 10;
Mike Stump11289f42009-09-09 15:08:12 +00001614
Mike Stump11289f42009-09-09 15:08:12 +00001615 const llvm::FunctionType *Ty =
Eli Friedman4f678f32009-12-09 03:05:59 +00001616 cast<llvm::FunctionType>(getTypes().ConvertType(FD->getType()));
Chris Lattner1eec6602007-08-31 04:31:45 +00001617
Anders Carlsson3c239482011-02-05 04:35:53 +00001618 return GetOrCreateLLVMFunction(Name, Ty, GlobalDecl(FD), /*ForVTable=*/false);
Chris Lattner1eec6602007-08-31 04:31:45 +00001619}
1620
Chris Lattnerb8be97e2007-12-18 00:25:38 +00001621llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys,
1622 unsigned NumTys) {
1623 return llvm::Intrinsic::getDeclaration(&getModule(),
1624 (llvm::Intrinsic::ID)IID, Tys, NumTys);
1625}
Chris Lattner1eec6602007-08-31 04:31:45 +00001626
Daniel Dunbar64509b22009-07-23 22:52:48 +00001627static llvm::StringMapEntry<llvm::Constant*> &
1628GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
1629 const StringLiteral *Literal,
Daniel Dunbar91ade142009-07-23 23:41:22 +00001630 bool TargetIsLSB,
Daniel Dunbar64509b22009-07-23 22:52:48 +00001631 bool &IsUTF16,
1632 unsigned &StringLength) {
Benjamin Kramer35b077e2010-08-17 12:54:38 +00001633 llvm::StringRef String = Literal->getString();
1634 unsigned NumBytes = String.size();
Daniel Dunbar64509b22009-07-23 22:52:48 +00001635
Daniel Dunbarb879c3c2009-09-22 10:03:52 +00001636 // Check for simple case.
1637 if (!Literal->containsNonAsciiOrNull()) {
1638 StringLength = NumBytes;
Benjamin Kramer35b077e2010-08-17 12:54:38 +00001639 return Map.GetOrCreateValue(String);
Daniel Dunbarb879c3c2009-09-22 10:03:52 +00001640 }
1641
Daniel Dunbar64509b22009-07-23 22:52:48 +00001642 // Otherwise, convert the UTF8 literals into a byte string.
1643 llvm::SmallVector<UTF16, 128> ToBuf(NumBytes);
Benjamin Kramer35b077e2010-08-17 12:54:38 +00001644 const UTF8 *FromPtr = (UTF8 *)String.data();
Daniel Dunbar64509b22009-07-23 22:52:48 +00001645 UTF16 *ToPtr = &ToBuf[0];
Mike Stump11289f42009-09-09 15:08:12 +00001646
Fariborz Jahanian535618b2010-09-07 19:57:04 +00001647 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
1648 &ToPtr, ToPtr + NumBytes,
1649 strictConversion);
Mike Stump11289f42009-09-09 15:08:12 +00001650
Daniel Dunbar91ade142009-07-23 23:41:22 +00001651 // ConvertUTF8toUTF16 returns the length in ToPtr.
Daniel Dunbar64509b22009-07-23 22:52:48 +00001652 StringLength = ToPtr - &ToBuf[0];
Daniel Dunbar91ade142009-07-23 23:41:22 +00001653
1654 // Render the UTF-16 string into a byte array and convert to the target byte
1655 // order.
1656 //
1657 // FIXME: This isn't something we should need to do here.
1658 llvm::SmallString<128> AsBytes;
1659 AsBytes.reserve(StringLength * 2);
1660 for (unsigned i = 0; i != StringLength; ++i) {
1661 unsigned short Val = ToBuf[i];
1662 if (TargetIsLSB) {
1663 AsBytes.push_back(Val & 0xFF);
1664 AsBytes.push_back(Val >> 8);
1665 } else {
1666 AsBytes.push_back(Val >> 8);
1667 AsBytes.push_back(Val & 0xFF);
1668 }
1669 }
Daniel Dunbar4d93a4f2009-08-03 21:47:08 +00001670 // Append one extra null character, the second is automatically added by our
1671 // caller.
1672 AsBytes.push_back(0);
Daniel Dunbar91ade142009-07-23 23:41:22 +00001673
Daniel Dunbar64509b22009-07-23 22:52:48 +00001674 IsUTF16 = true;
Daniel Dunbar91ade142009-07-23 23:41:22 +00001675 return Map.GetOrCreateValue(llvm::StringRef(AsBytes.data(), AsBytes.size()));
Daniel Dunbar64509b22009-07-23 22:52:48 +00001676}
1677
1678llvm::Constant *
1679CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
1680 unsigned StringLength = 0;
1681 bool isUTF16 = false;
1682 llvm::StringMapEntry<llvm::Constant*> &Entry =
Mike Stump11289f42009-09-09 15:08:12 +00001683 GetConstantCFStringEntry(CFConstantStringMap, Literal,
Daniel Dunbar91ade142009-07-23 23:41:22 +00001684 getTargetData().isLittleEndian(),
1685 isUTF16, StringLength);
Mike Stump11289f42009-09-09 15:08:12 +00001686
Daniel Dunbar64509b22009-07-23 22:52:48 +00001687 if (llvm::Constant *C = Entry.getValue())
1688 return C;
Mike Stump11289f42009-09-09 15:08:12 +00001689
Owen Anderson41a75022009-08-13 21:57:51 +00001690 llvm::Constant *Zero =
1691 llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext));
Daniel Dunbard644ad62008-08-23 18:37:06 +00001692 llvm::Constant *Zeros[] = { Zero, Zero };
Mike Stump11289f42009-09-09 15:08:12 +00001693
Chris Lattneraa64ca22009-07-16 16:48:25 +00001694 // If we don't already have it, get __CFConstantStringClassReference.
Anders Carlssonb04ea612007-08-21 00:21:21 +00001695 if (!CFConstantStringClassRef) {
1696 const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +00001697 Ty = llvm::ArrayType::get(Ty, 0);
Mike Stump11289f42009-09-09 15:08:12 +00001698 llvm::Constant *GV = CreateRuntimeVariable(Ty,
Chris Lattneraa64ca22009-07-16 16:48:25 +00001699 "__CFConstantStringClassReference");
Daniel Dunbard644ad62008-08-23 18:37:06 +00001700 // Decay array -> ptr
1701 CFConstantStringClassRef =
Owen Andersonade90fd2009-07-29 18:54:39 +00001702 llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
Anders Carlssonb04ea612007-08-21 00:21:21 +00001703 }
Mike Stump11289f42009-09-09 15:08:12 +00001704
Anders Carlssonc2480a52008-11-15 18:54:24 +00001705 QualType CFTy = getContext().getCFConstantStringType();
Daniel Dunbard644ad62008-08-23 18:37:06 +00001706
Mike Stump11289f42009-09-09 15:08:12 +00001707 const llvm::StructType *STy =
Anders Carlssonc2480a52008-11-15 18:54:24 +00001708 cast<llvm::StructType>(getTypes().ConvertType(CFTy));
1709
Anders Carlsson157c3212009-08-16 05:55:31 +00001710 std::vector<llvm::Constant*> Fields(4);
Douglas Gregor91f84212008-12-11 16:49:14 +00001711
Anders Carlssonb04ea612007-08-21 00:21:21 +00001712 // Class pointer.
Anders Carlsson157c3212009-08-16 05:55:31 +00001713 Fields[0] = CFConstantStringClassRef;
Mike Stump11289f42009-09-09 15:08:12 +00001714
Anders Carlssonb04ea612007-08-21 00:21:21 +00001715 // Flags.
Daniel Dunbard644ad62008-08-23 18:37:06 +00001716 const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
Mike Stump11289f42009-09-09 15:08:12 +00001717 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
Anders Carlsson157c3212009-08-16 05:55:31 +00001718 llvm::ConstantInt::get(Ty, 0x07C8);
1719
Anders Carlssonb04ea612007-08-21 00:21:21 +00001720 // String pointer.
Owen Anderson41a75022009-08-13 21:57:51 +00001721 llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str());
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +00001722
Chris Lattner3afa3e12009-07-16 05:03:48 +00001723 llvm::GlobalValue::LinkageTypes Linkage;
Chris Lattner4f8a2e22009-10-14 05:55:45 +00001724 bool isConstant;
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +00001725 if (isUTF16) {
Chris Lattner4f8a2e22009-10-14 05:55:45 +00001726 // FIXME: why do utf strings get "_" labels instead of "L" labels?
Chris Lattner3afa3e12009-07-16 05:03:48 +00001727 Linkage = llvm::GlobalValue::InternalLinkage;
Chris Lattner4f8a2e22009-10-14 05:55:45 +00001728 // Note: -fwritable-strings doesn't make unicode CFStrings writable, but
1729 // does make plain ascii ones writable.
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +00001730 isConstant = true;
Chris Lattner4f8a2e22009-10-14 05:55:45 +00001731 } else {
Rafael Espindola7a6cf012011-03-14 17:55:00 +00001732 // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error
1733 // when using private linkage. It is not clear if this is a bug in ld
1734 // or a reasonable new restriction.
Rafael Espindola0c1f0982011-03-14 21:08:19 +00001735 Linkage = llvm::GlobalValue::LinkerPrivateLinkage;
Chris Lattner4f8a2e22009-10-14 05:55:45 +00001736 isConstant = !Features.WritableStrings;
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +00001737 }
Chris Lattner4f8a2e22009-10-14 05:55:45 +00001738
Mike Stump11289f42009-09-09 15:08:12 +00001739 llvm::GlobalVariable *GV =
Chris Lattner4f8a2e22009-10-14 05:55:45 +00001740 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
1741 ".str");
Rafael Espindolae79d43da2011-01-17 16:31:00 +00001742 GV->setUnnamedAddr(true);
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +00001743 if (isUTF16) {
Ken Dycka0f99ff2010-01-26 18:46:23 +00001744 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
1745 GV->setAlignment(Align.getQuantity());
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +00001746 }
Anders Carlsson157c3212009-08-16 05:55:31 +00001747 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
1748
Anders Carlssonb04ea612007-08-21 00:21:21 +00001749 // String length.
1750 Ty = getTypes().ConvertType(getContext().LongTy);
Anders Carlsson157c3212009-08-16 05:55:31 +00001751 Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
Mike Stump11289f42009-09-09 15:08:12 +00001752
Anders Carlssonb04ea612007-08-21 00:21:21 +00001753 // The struct.
Owen Anderson0e0189d2009-07-27 22:29:56 +00001754 C = llvm::ConstantStruct::get(STy, Fields);
Mike Stump11289f42009-09-09 15:08:12 +00001755 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
1756 llvm::GlobalVariable::PrivateLinkage, C,
Chris Lattner3afa3e12009-07-16 05:03:48 +00001757 "_unnamed_cfstring_");
Daniel Dunbar08b216a2009-03-31 23:42:16 +00001758 if (const char *Sect = getContext().Target.getCFStringSection())
1759 GV->setSection(Sect);
Daniel Dunbar64509b22009-07-23 22:52:48 +00001760 Entry.setValue(GV);
Mike Stump11289f42009-09-09 15:08:12 +00001761
Anders Carlsson41b7c6b2007-11-01 00:41:52 +00001762 return GV;
Anders Carlssonb04ea612007-08-21 00:21:21 +00001763}
Chris Lattnerfb300092007-11-28 05:34:05 +00001764
Fariborz Jahanian63408e82010-04-22 20:26:39 +00001765llvm::Constant *
Fariborz Jahanian50c925f2010-10-19 17:19:29 +00001766CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
Fariborz Jahaniane804c282010-04-23 17:41:07 +00001767 unsigned StringLength = 0;
1768 bool isUTF16 = false;
1769 llvm::StringMapEntry<llvm::Constant*> &Entry =
1770 GetConstantCFStringEntry(CFConstantStringMap, Literal,
1771 getTargetData().isLittleEndian(),
1772 isUTF16, StringLength);
1773
1774 if (llvm::Constant *C = Entry.getValue())
1775 return C;
1776
1777 llvm::Constant *Zero =
1778 llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext));
1779 llvm::Constant *Zeros[] = { Zero, Zero };
1780
Fariborz Jahaniand3fa7012010-04-23 22:33:39 +00001781 // If we don't already have it, get _NSConstantStringClassReference.
Fariborz Jahanian50c925f2010-10-19 17:19:29 +00001782 if (!ConstantStringClassRef) {
1783 std::string StringClass(getLangOptions().ObjCConstantStringClass);
Fariborz Jahaniane804c282010-04-23 17:41:07 +00001784 const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
1785 Ty = llvm::ArrayType::get(Ty, 0);
Fariborz Jahanian50c925f2010-10-19 17:19:29 +00001786 llvm::Constant *GV;
1787 if (StringClass.empty())
1788 GV = CreateRuntimeVariable(Ty,
1789 Features.ObjCNonFragileABI ?
1790 "OBJC_CLASS_$_NSConstantString" :
1791 "_NSConstantStringClassReference");
1792 else {
1793 std::string str;
1794 if (Features.ObjCNonFragileABI)
1795 str = "OBJC_CLASS_$_" + StringClass;
1796 else
1797 str = "_" + StringClass + "ClassReference";
1798 GV = CreateRuntimeVariable(Ty, str);
1799 }
Fariborz Jahaniane804c282010-04-23 17:41:07 +00001800 // Decay array -> ptr
Fariborz Jahanian50c925f2010-10-19 17:19:29 +00001801 ConstantStringClassRef =
1802 llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
Fariborz Jahaniane804c282010-04-23 17:41:07 +00001803 }
1804
1805 QualType NSTy = getContext().getNSConstantStringType();
1806
1807 const llvm::StructType *STy =
1808 cast<llvm::StructType>(getTypes().ConvertType(NSTy));
1809
1810 std::vector<llvm::Constant*> Fields(3);
1811
1812 // Class pointer.
Fariborz Jahanian50c925f2010-10-19 17:19:29 +00001813 Fields[0] = ConstantStringClassRef;
Fariborz Jahaniane804c282010-04-23 17:41:07 +00001814
1815 // String pointer.
1816 llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str());
1817
1818 llvm::GlobalValue::LinkageTypes Linkage;
1819 bool isConstant;
1820 if (isUTF16) {
1821 // FIXME: why do utf strings get "_" labels instead of "L" labels?
1822 Linkage = llvm::GlobalValue::InternalLinkage;
1823 // Note: -fwritable-strings doesn't make unicode NSStrings writable, but
1824 // does make plain ascii ones writable.
1825 isConstant = true;
1826 } else {
1827 Linkage = llvm::GlobalValue::PrivateLinkage;
1828 isConstant = !Features.WritableStrings;
1829 }
1830
1831 llvm::GlobalVariable *GV =
1832 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
1833 ".str");
Rafael Espindolade089d42011-01-17 22:11:21 +00001834 GV->setUnnamedAddr(true);
Fariborz Jahaniane804c282010-04-23 17:41:07 +00001835 if (isUTF16) {
1836 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
1837 GV->setAlignment(Align.getQuantity());
1838 }
1839 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
1840
1841 // String length.
1842 const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
1843 Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
1844
1845 // The struct.
1846 C = llvm::ConstantStruct::get(STy, Fields);
1847 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
1848 llvm::GlobalVariable::PrivateLinkage, C,
1849 "_unnamed_nsstring_");
1850 // FIXME. Fix section.
Fariborz Jahaniand3fa7012010-04-23 22:33:39 +00001851 if (const char *Sect =
1852 Features.ObjCNonFragileABI
1853 ? getContext().Target.getNSStringNonFragileABISection()
1854 : getContext().Target.getNSStringSection())
Fariborz Jahaniane804c282010-04-23 17:41:07 +00001855 GV->setSection(Sect);
1856 Entry.setValue(GV);
1857
1858 return GV;
Fariborz Jahanian63408e82010-04-22 20:26:39 +00001859}
1860
Daniel Dunbarc4baa062008-08-13 23:20:05 +00001861/// GetStringForStringLiteral - Return the appropriate bytes for a
Daniel Dunbar6dfdf8c2008-08-10 20:25:57 +00001862/// string literal, properly padded to match the literal type.
Daniel Dunbarc4baa062008-08-13 23:20:05 +00001863std::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) {
Ken Dycka45a70c2011-01-29 17:53:12 +00001864 const ASTContext &Context = getContext();
Daniel Dunbar6dfdf8c2008-08-10 20:25:57 +00001865 const ConstantArrayType *CAT =
Ken Dycka45a70c2011-01-29 17:53:12 +00001866 Context.getAsConstantArrayType(E->getType());
Daniel Dunbar6dfdf8c2008-08-10 20:25:57 +00001867 assert(CAT && "String isn't pointer or array!");
Mike Stump11289f42009-09-09 15:08:12 +00001868
Chris Lattnerd42c29f2009-02-26 23:01:51 +00001869 // Resize the string to the right size.
Daniel Dunbar6dfdf8c2008-08-10 20:25:57 +00001870 uint64_t RealLen = CAT->getSize().getZExtValue();
Mike Stump11289f42009-09-09 15:08:12 +00001871
Chris Lattnerd42c29f2009-02-26 23:01:51 +00001872 if (E->isWide())
Ken Dycka45a70c2011-01-29 17:53:12 +00001873 RealLen *= Context.Target.getWCharWidth() / Context.getCharWidth();
Mike Stump11289f42009-09-09 15:08:12 +00001874
Benjamin Kramer35b077e2010-08-17 12:54:38 +00001875 std::string Str = E->getString().str();
Daniel Dunbar6dfdf8c2008-08-10 20:25:57 +00001876 Str.resize(RealLen, '\0');
Mike Stump11289f42009-09-09 15:08:12 +00001877
Daniel Dunbar6dfdf8c2008-08-10 20:25:57 +00001878 return Str;
1879}
1880
Daniel Dunbarc4baa062008-08-13 23:20:05 +00001881/// GetAddrOfConstantStringFromLiteral - Return a pointer to a
1882/// constant array for the given string literal.
1883llvm::Constant *
1884CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
1885 // FIXME: This can be more efficient.
Eli Friedman49ddc5f2009-11-16 05:55:46 +00001886 // FIXME: We shouldn't need to bitcast the constant in the wide string case.
1887 llvm::Constant *C = GetAddrOfConstantString(GetStringForStringLiteral(S));
1888 if (S->isWide()) {
1889 llvm::Type *DestTy =
1890 llvm::PointerType::getUnqual(getTypes().ConvertType(S->getType()));
1891 C = llvm::ConstantExpr::getBitCast(C, DestTy);
1892 }
1893 return C;
Daniel Dunbarc4baa062008-08-13 23:20:05 +00001894}
1895
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00001896/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
1897/// array for the given ObjCEncodeExpr node.
1898llvm::Constant *
1899CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
1900 std::string Str;
1901 getContext().getObjCEncodingForType(E->getEncodedType(), Str);
Eli Friedman4663a332009-03-07 20:17:55 +00001902
1903 return GetAddrOfConstantCString(Str);
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00001904}
1905
1906
Chris Lattner36fc8792008-02-11 00:02:17 +00001907/// GenerateWritableString -- Creates storage for a string literal.
Benjamin Kramer0cd19fb2011-03-05 13:45:23 +00001908static llvm::Constant *GenerateStringLiteral(llvm::StringRef str,
Chris Lattnerfb300092007-11-28 05:34:05 +00001909 bool constant,
Daniel Dunbardfcf5992008-10-17 21:56:50 +00001910 CodeGenModule &CGM,
1911 const char *GlobalName) {
Daniel Dunbarc4baa062008-08-13 23:20:05 +00001912 // Create Constant for this string literal. Don't add a '\0'.
Owen Anderson41a75022009-08-13 21:57:51 +00001913 llvm::Constant *C =
1914 llvm::ConstantArray::get(CGM.getLLVMContext(), str, false);
Mike Stump11289f42009-09-09 15:08:12 +00001915
Chris Lattnerfb300092007-11-28 05:34:05 +00001916 // Create a global variable for this string
Rafael Espindolab7f60e32011-01-10 22:34:03 +00001917 llvm::GlobalVariable *GV =
1918 new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
1919 llvm::GlobalValue::PrivateLinkage,
1920 C, GlobalName);
1921 GV->setUnnamedAddr(true);
1922 return GV;
Chris Lattnerfb300092007-11-28 05:34:05 +00001923}
1924
Daniel Dunbarc4baa062008-08-13 23:20:05 +00001925/// GetAddrOfConstantString - Returns a pointer to a character array
1926/// containing the literal. This contents are exactly that of the
1927/// given string, i.e. it will not be null terminated automatically;
1928/// see GetAddrOfConstantCString. Note that whether the result is
1929/// actually a pointer to an LLVM constant depends on
1930/// Feature.WriteableStrings.
1931///
1932/// The result has pointer to array type.
Benjamin Kramer0cd19fb2011-03-05 13:45:23 +00001933llvm::Constant *CodeGenModule::GetAddrOfConstantString(llvm::StringRef Str,
Daniel Dunbardfcf5992008-10-17 21:56:50 +00001934 const char *GlobalName) {
Daniel Dunbar08b216a2009-03-31 23:42:16 +00001935 bool IsConstant = !Features.WritableStrings;
1936
1937 // Get the default prefix if a name wasn't specified.
1938 if (!GlobalName)
Chris Lattner3afa3e12009-07-16 05:03:48 +00001939 GlobalName = ".str";
Daniel Dunbar08b216a2009-03-31 23:42:16 +00001940
1941 // Don't share any string literals if strings aren't constant.
1942 if (!IsConstant)
Benjamin Kramer0cd19fb2011-03-05 13:45:23 +00001943 return GenerateStringLiteral(Str, false, *this, GlobalName);
Mike Stump11289f42009-09-09 15:08:12 +00001944
1945 llvm::StringMapEntry<llvm::Constant *> &Entry =
Benjamin Kramer0cd19fb2011-03-05 13:45:23 +00001946 ConstantStringMap.GetOrCreateValue(Str);
Chris Lattnerfb300092007-11-28 05:34:05 +00001947
1948 if (Entry.getValue())
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00001949 return Entry.getValue();
Chris Lattnerfb300092007-11-28 05:34:05 +00001950
1951 // Create a global variable for this.
Benjamin Kramer0cd19fb2011-03-05 13:45:23 +00001952 llvm::Constant *C = GenerateStringLiteral(Str, true, *this, GlobalName);
Chris Lattnerfb300092007-11-28 05:34:05 +00001953 Entry.setValue(C);
1954 return C;
1955}
Daniel Dunbarc4baa062008-08-13 23:20:05 +00001956
1957/// GetAddrOfConstantCString - Returns a pointer to a character
Benjamin Kramer0cd19fb2011-03-05 13:45:23 +00001958/// array containing the literal and a terminating '\0'
Daniel Dunbarc4baa062008-08-13 23:20:05 +00001959/// character. The result has pointer to array type.
Benjamin Kramer0cd19fb2011-03-05 13:45:23 +00001960llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str,
Daniel Dunbardfcf5992008-10-17 21:56:50 +00001961 const char *GlobalName){
Benjamin Kramer0cd19fb2011-03-05 13:45:23 +00001962 llvm::StringRef StrWithNull(Str.c_str(), Str.size() + 1);
1963 return GetAddrOfConstantString(StrWithNull, GlobalName);
Daniel Dunbarc4baa062008-08-13 23:20:05 +00001964}
Daniel Dunbarfce4be82008-08-15 23:26:23 +00001965
Daniel Dunbar89654ee2008-08-26 08:29:31 +00001966/// EmitObjCPropertyImplementations - Emit information for synthesized
1967/// properties for an implementation.
Mike Stump11289f42009-09-09 15:08:12 +00001968void CodeGenModule::EmitObjCPropertyImplementations(const
Daniel Dunbar89654ee2008-08-26 08:29:31 +00001969 ObjCImplementationDecl *D) {
Mike Stump11289f42009-09-09 15:08:12 +00001970 for (ObjCImplementationDecl::propimpl_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00001971 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
Daniel Dunbar89654ee2008-08-26 08:29:31 +00001972 ObjCPropertyImplDecl *PID = *i;
Mike Stump11289f42009-09-09 15:08:12 +00001973
Daniel Dunbar89654ee2008-08-26 08:29:31 +00001974 // Dynamic is just for type-checking.
1975 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
1976 ObjCPropertyDecl *PD = PID->getPropertyDecl();
1977
1978 // Determine which methods need to be implemented, some may have
1979 // been overridden. Note that ::isSynthesized is not the method
1980 // we want, that just indicates if the decl came from a
1981 // property. What we want to know is if the method is defined in
1982 // this implementation.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00001983 if (!D->getInstanceMethod(PD->getGetterName()))
Fariborz Jahanian3d8552a2008-12-09 20:23:04 +00001984 CodeGenFunction(*this).GenerateObjCGetter(
1985 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbar89654ee2008-08-26 08:29:31 +00001986 if (!PD->isReadOnly() &&
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00001987 !D->getInstanceMethod(PD->getSetterName()))
Fariborz Jahanian3d8552a2008-12-09 20:23:04 +00001988 CodeGenFunction(*this).GenerateObjCSetter(
1989 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbar89654ee2008-08-26 08:29:31 +00001990 }
1991 }
1992}
1993
John McCall6a4fa522011-03-22 07:05:39 +00001994static bool needsDestructMethod(ObjCImplementationDecl *impl) {
1995 ObjCInterfaceDecl *iface
1996 = const_cast<ObjCInterfaceDecl*>(impl->getClassInterface());
1997 for (ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
1998 ivar; ivar = ivar->getNextIvar())
1999 if (ivar->getType().isDestructedType())
2000 return true;
2001
2002 return false;
2003}
2004
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002005/// EmitObjCIvarInitializations - Emit information for ivar initialization
2006/// for an implementation.
2007void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
John McCall6a4fa522011-03-22 07:05:39 +00002008 // We might need a .cxx_destruct even if we don't have any ivar initializers.
2009 if (needsDestructMethod(D)) {
2010 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
2011 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
2012 ObjCMethodDecl *DTORMethod =
2013 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
2014 cxxSelector, getContext().VoidTy, 0, D, true,
2015 false, true, false, ObjCMethodDecl::Required);
2016 D->addInstanceMethod(DTORMethod);
2017 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
2018 }
2019
2020 // If the implementation doesn't have any ivar initializers, we don't need
2021 // a .cxx_construct.
David Chisnalla9e54602011-03-17 14:19:08 +00002022 if (D->getNumIvarInitializers() == 0)
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002023 return;
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002024
John McCall6a4fa522011-03-22 07:05:39 +00002025 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
2026 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002027 // The constructor returns 'self'.
2028 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
2029 D->getLocation(),
2030 D->getLocation(), cxxSelector,
2031 getContext().getObjCIdType(), 0,
John McCall6a4fa522011-03-22 07:05:39 +00002032 D, true, false, true, false,
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002033 ObjCMethodDecl::Required);
2034 D->addInstanceMethod(CTORMethod);
2035 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002036}
2037
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00002038/// EmitNamespace - Emit all declarations in a namespace.
Anders Carlsson237f3492009-04-01 00:58:25 +00002039void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002040 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
Anders Carlsson237f3492009-04-01 00:58:25 +00002041 I != E; ++I)
2042 EmitTopLevelDecl(*I);
2043}
2044
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00002045// EmitLinkageSpec - Emit all declarations in a linkage spec.
2046void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
Eli Friedmane480ce32009-08-01 20:48:04 +00002047 if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
2048 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00002049 ErrorUnsupported(LSD, "linkage spec");
2050 return;
2051 }
2052
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002053 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00002054 I != E; ++I)
2055 EmitTopLevelDecl(*I);
2056}
2057
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002058/// EmitTopLevelDecl - Emit code for a single top level declaration.
2059void CodeGenModule::EmitTopLevelDecl(Decl *D) {
2060 // If an error has occurred, stop code generation, but continue
2061 // parsing and semantic analysis (to ensure all warnings and errors
2062 // are emitted).
2063 if (Diags.hasErrorOccurred())
2064 return;
2065
Douglas Gregor70d83e22009-06-29 17:30:29 +00002066 // Ignore dependent declarations.
2067 if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
2068 return;
Mike Stump11289f42009-09-09 15:08:12 +00002069
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002070 switch (D->getKind()) {
Anders Carlsson6c0a6e42009-08-25 13:14:46 +00002071 case Decl::CXXConversion:
Anders Carlsson468fa632009-04-04 20:47:02 +00002072 case Decl::CXXMethod:
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002073 case Decl::Function:
Douglas Gregor70d83e22009-06-29 17:30:29 +00002074 // Skip function templates
2075 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate())
2076 return;
Mike Stump11289f42009-09-09 15:08:12 +00002077
Anders Carlssonecf9bf02009-09-10 23:43:36 +00002078 EmitGlobal(cast<FunctionDecl>(D));
2079 break;
2080
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002081 case Decl::Var:
Anders Carlssonecf9bf02009-09-10 23:43:36 +00002082 EmitGlobal(cast<VarDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002083 break;
2084
Anders Carlssonf7475242009-04-15 15:55:24 +00002085 // C++ Decls
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002086 case Decl::Namespace:
Anders Carlsson237f3492009-04-01 00:58:25 +00002087 EmitNamespace(cast<NamespaceDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002088 break;
Douglas Gregorfec52632009-06-20 00:51:54 +00002089 // No code generation needed.
John McCall1e9de052009-11-17 09:33:40 +00002090 case Decl::UsingShadow:
Douglas Gregorfec52632009-06-20 00:51:54 +00002091 case Decl::Using:
Douglas Gregore5feb512009-09-02 23:49:23 +00002092 case Decl::UsingDirective:
Douglas Gregor8f5d4422009-06-29 20:59:39 +00002093 case Decl::ClassTemplate:
2094 case Decl::FunctionTemplate:
Anders Carlsson649a17e2009-09-23 19:19:16 +00002095 case Decl::NamespaceAlias:
Douglas Gregorfec52632009-06-20 00:51:54 +00002096 break;
Anders Carlssonf7475242009-04-15 15:55:24 +00002097 case Decl::CXXConstructor:
Anders Carlsson0ade9712009-11-24 05:16:24 +00002098 // Skip function templates
2099 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate())
2100 return;
2101
Anders Carlssonf7475242009-04-15 15:55:24 +00002102 EmitCXXConstructors(cast<CXXConstructorDecl>(D));
2103 break;
Anders Carlssoneaa28f72009-04-17 01:58:57 +00002104 case Decl::CXXDestructor:
2105 EmitCXXDestructors(cast<CXXDestructorDecl>(D));
2106 break;
Anders Carlsson87835432009-06-11 21:22:55 +00002107
2108 case Decl::StaticAssert:
2109 // Nothing to do.
2110 break;
2111
Anders Carlssonf7475242009-04-15 15:55:24 +00002112 // Objective-C Decls
Mike Stump11289f42009-09-09 15:08:12 +00002113
Fariborz Jahanian3654e652009-03-18 22:33:24 +00002114 // Forward declarations, no (immediate) code generation.
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002115 case Decl::ObjCClass:
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002116 case Decl::ObjCForwardProtocol:
Chris Lattnerd18136a2009-04-01 02:36:43 +00002117 case Decl::ObjCInterface:
Chris Lattnerd18136a2009-04-01 02:36:43 +00002118 break;
Fariborz Jahanianbf9294f2010-08-23 18:51:39 +00002119
2120 case Decl::ObjCCategory: {
2121 ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(D);
2122 if (CD->IsClassExtension() && CD->hasSynthBitfield())
2123 Context.ResetObjCLayout(CD->getClassInterface());
2124 break;
2125 }
2126
Chris Lattnerd18136a2009-04-01 02:36:43 +00002127
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002128 case Decl::ObjCProtocol:
Fariborz Jahanian629aed92009-03-21 18:06:45 +00002129 Runtime->GenerateProtocol(cast<ObjCProtocolDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002130 break;
2131
2132 case Decl::ObjCCategoryImpl:
Daniel Dunbar89654ee2008-08-26 08:29:31 +00002133 // Categories have properties but don't support synthesize so we
2134 // can ignore them here.
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002135 Runtime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
2136 break;
2137
Daniel Dunbar89654ee2008-08-26 08:29:31 +00002138 case Decl::ObjCImplementation: {
2139 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
Fariborz Jahanianbf9294f2010-08-23 18:51:39 +00002140 if (Features.ObjCNonFragileABI2 && OMD->hasSynthBitfield())
2141 Context.ResetObjCLayout(OMD->getClassInterface());
Daniel Dunbar89654ee2008-08-26 08:29:31 +00002142 EmitObjCPropertyImplementations(OMD);
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002143 EmitObjCIvarInitializations(OMD);
Daniel Dunbar89654ee2008-08-26 08:29:31 +00002144 Runtime->GenerateClass(OMD);
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002145 break;
Mike Stump11289f42009-09-09 15:08:12 +00002146 }
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002147 case Decl::ObjCMethod: {
2148 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
2149 // If this is not a prototype, emit the body.
Argyrios Kyrtzidisddcd1322009-06-30 02:35:26 +00002150 if (OMD->getBody())
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002151 CodeGenFunction(*this).GenerateObjCMethod(OMD);
2152 break;
2153 }
Mike Stump11289f42009-09-09 15:08:12 +00002154 case Decl::ObjCCompatibleAlias:
Fariborz Jahanian17290c32009-01-08 01:10:55 +00002155 // compatibility-alias is a directive and has no code gen.
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002156 break;
2157
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00002158 case Decl::LinkageSpec:
2159 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002160 break;
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002161
2162 case Decl::FileScopeAsm: {
2163 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
Benjamin Kramerb11118b2009-12-11 13:33:18 +00002164 llvm::StringRef AsmString = AD->getAsmString()->getString();
Mike Stump11289f42009-09-09 15:08:12 +00002165
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002166 const std::string &S = getModule().getModuleInlineAsm();
2167 if (S.empty())
2168 getModule().setModuleInlineAsm(AsmString);
2169 else
Benjamin Kramerb11118b2009-12-11 13:33:18 +00002170 getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002171 break;
2172 }
Mike Stump11289f42009-09-09 15:08:12 +00002173
2174 default:
Mike Stump18bb9282009-05-16 07:57:57 +00002175 // Make sure we handled everything we should, every other kind is a
2176 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
2177 // function. Need to recode Decl::Kind to do that easily.
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002178 assert(isa<TypeDecl>(D) && "Unsupported decl kind");
2179 }
2180}
John McCall09ae0322010-07-06 23:57:41 +00002181
2182/// Turns the given pointer into a constant.
2183static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
2184 const void *Ptr) {
2185 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
2186 const llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
2187 return llvm::ConstantInt::get(i64, PtrInt);
2188}
2189
2190static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
2191 llvm::NamedMDNode *&GlobalMetadata,
2192 GlobalDecl D,
2193 llvm::GlobalValue *Addr) {
2194 if (!GlobalMetadata)
2195 GlobalMetadata =
2196 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
2197
2198 // TODO: should we report variant information for ctors/dtors?
2199 llvm::Value *Ops[] = {
2200 Addr,
2201 GetPointerConstant(CGM.getLLVMContext(), D.getDecl())
2202 };
2203 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops, 2));
2204}
2205
2206/// Emits metadata nodes associating all the global values in the
2207/// current module with the Decls they came from. This is useful for
2208/// projects using IR gen as a subroutine.
2209///
2210/// Since there's currently no way to associate an MDNode directly
2211/// with an llvm::GlobalValue, we create a global named metadata
2212/// with the name 'clang.global.decl.ptrs'.
2213void CodeGenModule::EmitDeclMetadata() {
2214 llvm::NamedMDNode *GlobalMetadata = 0;
2215
2216 // StaticLocalDeclMap
2217 for (llvm::DenseMap<GlobalDecl,llvm::StringRef>::iterator
2218 I = MangledDeclNames.begin(), E = MangledDeclNames.end();
2219 I != E; ++I) {
2220 llvm::GlobalValue *Addr = getModule().getNamedValue(I->second);
2221 EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr);
2222 }
2223}
2224
2225/// Emits metadata nodes for all the local variables in the current
2226/// function.
2227void CodeGenFunction::EmitDeclMetadata() {
2228 if (LocalDeclMap.empty()) return;
2229
2230 llvm::LLVMContext &Context = getLLVMContext();
2231
2232 // Find the unique metadata ID for this name.
2233 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
2234
2235 llvm::NamedMDNode *GlobalMetadata = 0;
2236
2237 for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator
2238 I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) {
2239 const Decl *D = I->first;
2240 llvm::Value *Addr = I->second;
2241
2242 if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
2243 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
2244 Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, &DAddr, 1));
2245 } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
2246 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
2247 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
2248 }
2249 }
2250}
Daniel Dunbar900546d2010-07-16 00:00:15 +00002251
2252///@name Custom Runtime Function Interfaces
2253///@{
2254//
2255// FIXME: These can be eliminated once we can have clients just get the required
2256// AST nodes from the builtin tables.
2257
2258llvm::Constant *CodeGenModule::getBlockObjectDispose() {
2259 if (BlockObjectDispose)
2260 return BlockObjectDispose;
2261
Daniel Dunbar3348e2d2010-07-16 00:00:19 +00002262 // If we saw an explicit decl, use that.
2263 if (BlockObjectDisposeDecl) {
2264 return BlockObjectDispose = GetAddrOfFunction(
2265 BlockObjectDisposeDecl,
2266 getTypes().GetFunctionType(BlockObjectDisposeDecl));
2267 }
2268
2269 // Otherwise construct the function by hand.
Daniel Dunbar900546d2010-07-16 00:00:15 +00002270 const llvm::FunctionType *FTy;
2271 std::vector<const llvm::Type*> ArgTys;
2272 const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext);
John McCallad7c5c12011-02-08 08:22:06 +00002273 ArgTys.push_back(Int8PtrTy);
Daniel Dunbar900546d2010-07-16 00:00:15 +00002274 ArgTys.push_back(llvm::Type::getInt32Ty(VMContext));
2275 FTy = llvm::FunctionType::get(ResultType, ArgTys, false);
2276 return BlockObjectDispose =
2277 CreateRuntimeFunction(FTy, "_Block_object_dispose");
2278}
2279
2280llvm::Constant *CodeGenModule::getBlockObjectAssign() {
2281 if (BlockObjectAssign)
2282 return BlockObjectAssign;
2283
Daniel Dunbar3348e2d2010-07-16 00:00:19 +00002284 // If we saw an explicit decl, use that.
2285 if (BlockObjectAssignDecl) {
2286 return BlockObjectAssign = GetAddrOfFunction(
2287 BlockObjectAssignDecl,
2288 getTypes().GetFunctionType(BlockObjectAssignDecl));
2289 }
2290
2291 // Otherwise construct the function by hand.
Daniel Dunbar900546d2010-07-16 00:00:15 +00002292 const llvm::FunctionType *FTy;
2293 std::vector<const llvm::Type*> ArgTys;
2294 const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext);
John McCallad7c5c12011-02-08 08:22:06 +00002295 ArgTys.push_back(Int8PtrTy);
2296 ArgTys.push_back(Int8PtrTy);
Daniel Dunbar900546d2010-07-16 00:00:15 +00002297 ArgTys.push_back(llvm::Type::getInt32Ty(VMContext));
2298 FTy = llvm::FunctionType::get(ResultType, ArgTys, false);
2299 return BlockObjectAssign =
2300 CreateRuntimeFunction(FTy, "_Block_object_assign");
2301}
2302
2303llvm::Constant *CodeGenModule::getNSConcreteGlobalBlock() {
2304 if (NSConcreteGlobalBlock)
2305 return NSConcreteGlobalBlock;
Daniel Dunbar3348e2d2010-07-16 00:00:19 +00002306
2307 // If we saw an explicit decl, use that.
2308 if (NSConcreteGlobalBlockDecl) {
2309 return NSConcreteGlobalBlock = GetAddrOfGlobalVar(
2310 NSConcreteGlobalBlockDecl,
2311 getTypes().ConvertType(NSConcreteGlobalBlockDecl->getType()));
2312 }
2313
2314 // Otherwise construct the variable by hand.
John McCallad7c5c12011-02-08 08:22:06 +00002315 return NSConcreteGlobalBlock =
2316 CreateRuntimeVariable(Int8PtrTy, "_NSConcreteGlobalBlock");
Daniel Dunbar900546d2010-07-16 00:00:15 +00002317}
2318
2319llvm::Constant *CodeGenModule::getNSConcreteStackBlock() {
2320 if (NSConcreteStackBlock)
2321 return NSConcreteStackBlock;
Daniel Dunbar3348e2d2010-07-16 00:00:19 +00002322
2323 // If we saw an explicit decl, use that.
2324 if (NSConcreteStackBlockDecl) {
2325 return NSConcreteStackBlock = GetAddrOfGlobalVar(
2326 NSConcreteStackBlockDecl,
2327 getTypes().ConvertType(NSConcreteStackBlockDecl->getType()));
2328 }
2329
2330 // Otherwise construct the variable by hand.
John McCallad7c5c12011-02-08 08:22:06 +00002331 return NSConcreteStackBlock =
2332 CreateRuntimeVariable(Int8PtrTy, "_NSConcreteStackBlock");
Daniel Dunbar900546d2010-07-16 00:00:15 +00002333}
2334
2335///@}