blob: 6602cc46bf8ed0543bb9972f75c4d25fcef1f191 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This coordinates the per-module state used while generating code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenModule.h"
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +000015#include "CGCUDARuntime.h"
John McCall4c40d982010-08-31 07:33:07 +000016#include "CGCXXABI.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000017#include "CGCall.h"
18#include "CGDebugInfo.h"
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +000019#include "CGObjCRuntime.h"
Peter Collingbourne8c25fc52011-09-19 21:14:35 +000020#include "CGOpenCLRuntime.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000021#include "CodeGenFunction.h"
22#include "CodeGenTBAA.h"
Anton Korobeynikov82d0a412010-01-10 12:58:08 +000023#include "TargetInfo.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000024#include "clang/AST/ASTContext.h"
Ken Dyck687cc4a2010-01-26 13:48:07 +000025#include "clang/AST/CharUnits.h"
Chris Lattner21ef7ae2008-11-04 16:51:42 +000026#include "clang/AST/DeclCXX.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000027#include "clang/AST/DeclObjC.h"
Douglas Gregoraf896892010-06-21 18:41:26 +000028#include "clang/AST/DeclTemplate.h"
Peter Collingbourne14110472011-01-13 18:57:25 +000029#include "clang/AST/Mangle.h"
Anders Carlsson1a5e0d72009-11-30 23:41:22 +000030#include "clang/AST/RecordLayout.h"
Rafael Espindolaa411d2f2011-10-26 20:41:06 +000031#include "clang/AST/RecursiveASTVisitor.h"
Rafael Espindolabcf6b982011-12-19 14:41:01 +000032#include "clang/Basic/Builtins.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000033#include "clang/Basic/ConvertUTF.h"
Chris Lattner2c8569d2007-12-02 07:19:18 +000034#include "clang/Basic/Diagnostic.h"
Nate Begeman8bd4afe2008-04-19 04:17:09 +000035#include "clang/Basic/SourceManager.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000036#include "clang/Basic/TargetInfo.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000037#include "clang/Frontend/CodeGenOptions.h"
Sebastian Redl19b1a6e2012-02-25 20:51:20 +000038#include "llvm/ADT/APSInt.h"
John McCall6374c332010-03-06 00:35:14 +000039#include "llvm/ADT/Triple.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000040#include "llvm/CallingConv.h"
Micah Villmow25a6a842012-10-08 16:25:52 +000041#include "llvm/DataLayout.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000042#include "llvm/Intrinsics.h"
43#include "llvm/LLVMContext.h"
44#include "llvm/Module.h"
Gabor Greif6ba728d2010-04-10 02:56:12 +000045#include "llvm/Support/CallSite.h"
Chris Lattner78f7ece2009-11-07 09:22:46 +000046#include "llvm/Support/ErrorHandling.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000047#include "llvm/Target/Mangler.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000048using namespace clang;
49using namespace CodeGen;
50
Julien Lerouge77f68bb2011-09-09 22:41:49 +000051static const char AnnotationSection[] = "llvm.metadata";
52
John McCallf16aa102010-08-22 21:01:12 +000053static CGCXXABI &createCXXABI(CodeGenModule &CGM) {
Douglas Gregorbcfd1f52011-09-02 00:18:52 +000054 switch (CGM.getContext().getTargetInfo().getCXXABI()) {
John McCallf16aa102010-08-22 21:01:12 +000055 case CXXABI_ARM: return *CreateARMCXXABI(CGM);
56 case CXXABI_Itanium: return *CreateItaniumCXXABI(CGM);
57 case CXXABI_Microsoft: return *CreateMicrosoftCXXABI(CGM);
58 }
59
60 llvm_unreachable("invalid C++ ABI kind");
John McCallf16aa102010-08-22 21:01:12 +000061}
62
Reid Spencer5f016e22007-07-11 17:01:13 +000063
Chandler Carruth2811ccf2009-11-12 17:24:48 +000064CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
Micah Villmow25a6a842012-10-08 16:25:52 +000065 llvm::Module &M, const llvm::DataLayout &TD,
David Blaikied6471f72011-09-25 23:23:43 +000066 DiagnosticsEngine &diags)
David Blaikie4e4d0842012-03-11 07:00:24 +000067 : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TheModule(M),
Micah Villmow25a6a842012-10-08 16:25:52 +000068 TheDataLayout(TD), TheTargetCodeGenInfo(0), Diags(diags),
John McCallf16aa102010-08-22 21:01:12 +000069 ABI(createCXXABI(*this)),
John McCallde5d3c72012-02-17 03:33:10 +000070 Types(*this),
Dan Gohman3d5aff52010-10-14 23:06:10 +000071 TBAA(0),
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +000072 VTables(*this), ObjCRuntime(0), OpenCLRuntime(0), CUDARuntime(0),
Dan Gohmanb49bd272012-02-16 00:57:37 +000073 DebugInfo(0), ARCData(0), NoObjCARCExceptionsMetadata(0),
74 RRData(0), CFConstantStringClassRef(0),
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +000075 ConstantStringClassRef(0), NSConstantStringType(0),
Daniel Dunbar673431a2010-07-16 00:00:15 +000076 VMContext(M.getContext()),
77 NSConcreteGlobalBlock(0), NSConcreteStackBlock(0),
John McCalld16c2cf2011-02-08 08:22:06 +000078 BlockObjectAssign(0), BlockObjectDispose(0),
79 BlockDescriptorType(0), GenericBlockLiteralType(0) {
Chris Lattner8b418682012-02-07 00:39:47 +000080
81 // Initialize the type cache.
82 llvm::LLVMContext &LLVMContext = M.getContext();
83 VoidTy = llvm::Type::getVoidTy(LLVMContext);
84 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
85 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
86 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
87 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
88 FloatTy = llvm::Type::getFloatTy(LLVMContext);
89 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
90 PointerWidthInBits = C.getTargetInfo().getPointerWidth(0);
91 PointerAlignInBytes =
92 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
93 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
94 IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits);
95 Int8PtrTy = Int8Ty->getPointerTo(0);
96 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
97
David Blaikie4e4d0842012-03-11 07:00:24 +000098 if (LangOpts.ObjC1)
Peter Collingbourne8c25fc52011-09-19 21:14:35 +000099 createObjCRuntime();
David Blaikie4e4d0842012-03-11 07:00:24 +0000100 if (LangOpts.OpenCL)
Peter Collingbourne8c25fc52011-09-19 21:14:35 +0000101 createOpenCLRuntime();
David Blaikie4e4d0842012-03-11 07:00:24 +0000102 if (LangOpts.CUDA)
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +0000103 createCUDARuntime();
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +0000104
Kostya Serebryanyc9fe6052012-04-24 06:57:01 +0000105 // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
Richard Smithca1b62a2012-11-05 21:48:12 +0000106 if (LangOpts.SanitizeThread ||
Kostya Serebryanyc9fe6052012-04-24 06:57:01 +0000107 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
108 TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(),
Dan Gohman0b5c4fc2010-10-15 20:23:12 +0000109 ABI.getMangleContext());
Dan Gohman3d5aff52010-10-14 23:06:10 +0000110
Nick Lewyckye8ba8d72011-04-21 23:44:07 +0000111 // If debug info or coverage generation is enabled, create the CGDebugInfo
112 // object.
Douglas Gregor4cdad312012-10-23 20:05:01 +0000113 if (CodeGenOpts.getDebugInfo() != CodeGenOptions::NoDebugInfo ||
Alexey Samsonov3a70cd62012-04-27 07:24:20 +0000114 CodeGenOpts.EmitGcovArcs ||
Nick Lewyckye8ba8d72011-04-21 23:44:07 +0000115 CodeGenOpts.EmitGcovNotes)
116 DebugInfo = new CGDebugInfo(*this);
John McCalld16c2cf2011-02-08 08:22:06 +0000117
118 Block.GlobalUniqueCount = 0;
John McCall5936e332011-02-15 09:22:45 +0000119
David Blaikie4e4d0842012-03-11 07:00:24 +0000120 if (C.getLangOpts().ObjCAutoRefCount)
John McCallf85e1932011-06-15 23:02:42 +0000121 ARCData = new ARCEntrypoints();
122 RRData = new RREntrypoints();
Chris Lattner2b94fe32008-03-01 08:45:05 +0000123}
124
125CodeGenModule::~CodeGenModule() {
Peter Collingbournee9265232011-07-27 20:29:46 +0000126 delete ObjCRuntime;
Peter Collingbourne8c25fc52011-09-19 21:14:35 +0000127 delete OpenCLRuntime;
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +0000128 delete CUDARuntime;
Ted Kremenek0628b722011-10-08 05:28:26 +0000129 delete TheTargetCodeGenInfo;
John McCallf16aa102010-08-22 21:01:12 +0000130 delete &ABI;
Dan Gohman4376c852010-10-15 18:04:46 +0000131 delete TBAA;
Ted Kremenek815c78f2008-08-05 18:50:11 +0000132 delete DebugInfo;
John McCallf85e1932011-06-15 23:02:42 +0000133 delete ARCData;
134 delete RRData;
Ted Kremenek815c78f2008-08-05 18:50:11 +0000135}
136
David Chisnall0d13f6f2010-01-23 02:40:42 +0000137void CodeGenModule::createObjCRuntime() {
John McCall260611a2012-06-20 06:18:46 +0000138 // This is just isGNUFamily(), but we want to force implementors of
139 // new ABIs to decide how best to do this.
140 switch (LangOpts.ObjCRuntime.getKind()) {
David Chisnall11d3f4c2012-07-03 20:49:52 +0000141 case ObjCRuntime::GNUstep:
142 case ObjCRuntime::GCC:
John McCallf7226fb2012-07-12 02:07:58 +0000143 case ObjCRuntime::ObjFW:
Peter Collingbournee9265232011-07-27 20:29:46 +0000144 ObjCRuntime = CreateGNUObjCRuntime(*this);
John McCall260611a2012-06-20 06:18:46 +0000145 return;
146
147 case ObjCRuntime::FragileMacOSX:
148 case ObjCRuntime::MacOSX:
149 case ObjCRuntime::iOS:
Peter Collingbournee9265232011-07-27 20:29:46 +0000150 ObjCRuntime = CreateMacObjCRuntime(*this);
John McCall260611a2012-06-20 06:18:46 +0000151 return;
152 }
153 llvm_unreachable("bad runtime kind");
David Chisnall0d13f6f2010-01-23 02:40:42 +0000154}
155
Peter Collingbourne8c25fc52011-09-19 21:14:35 +0000156void CodeGenModule::createOpenCLRuntime() {
157 OpenCLRuntime = new CGOpenCLRuntime(*this);
158}
159
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +0000160void CodeGenModule::createCUDARuntime() {
161 CUDARuntime = CreateNVCUDARuntime(*this);
162}
163
Ted Kremenek815c78f2008-08-05 18:50:11 +0000164void CodeGenModule::Release() {
Chris Lattner82227ff2009-03-22 21:21:57 +0000165 EmitDeferred();
Eli Friedman6c6bda32010-01-08 00:50:11 +0000166 EmitCXXGlobalInitFunc();
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000167 EmitCXXGlobalDtorFunc();
Peter Collingbournee9265232011-07-27 20:29:46 +0000168 if (ObjCRuntime)
169 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
Daniel Dunbar208ff5e2008-08-11 18:12:00 +0000170 AddGlobalCtor(ObjCInitFunction);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000171 EmitCtorList(GlobalCtors, "llvm.global_ctors");
172 EmitCtorList(GlobalDtors, "llvm.global_dtors");
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000173 EmitGlobalAnnotations();
Daniel Dunbar02698712009-02-13 20:29:50 +0000174 EmitLLVMUsed();
John McCall744016d2010-07-06 23:57:41 +0000175
John McCallb2593832010-09-16 06:16:50 +0000176 SimplifyPersonality();
177
John McCall744016d2010-07-06 23:57:41 +0000178 if (getCodeGenOpts().EmitDeclMetadata)
179 EmitDeclMetadata();
Nick Lewycky5ea4f442011-05-04 20:46:58 +0000180
181 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
Nick Lewycky3dc05412011-05-05 00:08:20 +0000182 EmitCoverageFile();
Devang Patelf391dbe2011-08-16 20:58:22 +0000183
184 if (DebugInfo)
185 DebugInfo->finalize();
Daniel Dunbarf1968f22008-10-01 00:49:24 +0000186}
187
Devang Patele80d5672011-03-23 16:29:39 +0000188void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
189 // Make sure that this type is translated.
190 Types.UpdateCompletedType(TD);
Devang Patele80d5672011-03-23 16:29:39 +0000191}
192
Dan Gohman3d5aff52010-10-14 23:06:10 +0000193llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) {
194 if (!TBAA)
195 return 0;
196 return TBAA->getTBAAInfo(QTy);
197}
198
Kostya Serebryany8cb4a072012-03-26 17:03:51 +0000199llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() {
200 if (!TBAA)
201 return 0;
202 return TBAA->getTBAAInfoForVTablePtr();
203}
204
Dan Gohmanb22c7dc2012-09-28 21:58:29 +0000205llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) {
206 if (!TBAA)
207 return 0;
208 return TBAA->getTBAAStructInfo(QTy);
209}
210
Dan Gohman3d5aff52010-10-14 23:06:10 +0000211void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst,
212 llvm::MDNode *TBAAInfo) {
213 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo);
214}
215
John McCall6374c332010-03-06 00:35:14 +0000216bool CodeGenModule::isTargetDarwin() const {
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000217 return getContext().getTargetInfo().getTriple().isOSDarwin();
John McCall6374c332010-03-06 00:35:14 +0000218}
219
Chandler Carruth0f30a122012-03-30 19:44:53 +0000220void CodeGenModule::Error(SourceLocation loc, StringRef error) {
221 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, error);
John McCall32096692011-03-18 02:56:14 +0000222 getDiags().Report(Context.getFullLoc(loc), diagID);
223}
224
Daniel Dunbar488e9932008-08-16 00:56:44 +0000225/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattner2c8569d2007-12-02 07:19:18 +0000226/// specified stmt yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000227void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
228 bool OmitOnError) {
229 if (OmitOnError && getDiags().hasErrorOccurred())
230 return;
David Blaikied6471f72011-09-25 23:23:43 +0000231 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
Daniel Dunbar56b80012009-02-06 19:18:03 +0000232 "cannot compile this %0 yet");
Chris Lattner2c8569d2007-12-02 07:19:18 +0000233 std::string Msg = Type;
Chris Lattner0a14eee2008-11-18 07:04:44 +0000234 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
235 << Msg << S->getSourceRange();
Chris Lattner2c8569d2007-12-02 07:19:18 +0000236}
Chris Lattner58c3f9e2007-12-02 06:27:33 +0000237
Daniel Dunbar488e9932008-08-16 00:56:44 +0000238/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000239/// specified decl yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000240void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
241 bool OmitOnError) {
242 if (OmitOnError && getDiags().hasErrorOccurred())
243 return;
David Blaikied6471f72011-09-25 23:23:43 +0000244 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
Daniel Dunbar56b80012009-02-06 19:18:03 +0000245 "cannot compile this %0 yet");
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000246 std::string Msg = Type;
Chris Lattner0a14eee2008-11-18 07:04:44 +0000247 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000248}
249
John McCallbc8d40d2011-06-24 21:55:10 +0000250llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
251 return llvm::ConstantInt::get(SizeTy, size.getQuantity());
252}
253
Mike Stump1eb44332009-09-09 15:08:12 +0000254void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
Anders Carlsson0ffeaad2011-01-29 19:39:23 +0000255 const NamedDecl *D) const {
Daniel Dunbar04d40782009-04-14 06:00:08 +0000256 // Internal definitions always have default visibility.
Chris Lattnerdf102fc2009-04-14 05:27:13 +0000257 if (GV->hasLocalLinkage()) {
Daniel Dunbar7e714cd2009-04-10 20:26:50 +0000258 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar6ab187a2009-04-07 05:48:37 +0000259 return;
Daniel Dunbar7e714cd2009-04-10 20:26:50 +0000260 }
Daniel Dunbar6ab187a2009-04-07 05:48:37 +0000261
John McCallaf146032010-10-30 11:50:40 +0000262 // Set visibility for definitions.
263 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility();
Fariborz Jahanianc7c90582011-06-16 20:14:50 +0000264 if (LV.visibilityExplicit() || !GV->hasAvailableExternallyLinkage())
265 GV->setVisibility(GetLLVMVisibility(LV.visibility()));
Dan Gohman4f8d1232008-05-22 00:50:06 +0000266}
267
Hans Wennborgde981f32012-06-28 08:01:44 +0000268static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
269 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
270 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
271 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
272 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
273 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
274}
275
276static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
277 CodeGenOptions::TLSModel M) {
278 switch (M) {
279 case CodeGenOptions::GeneralDynamicTLSModel:
280 return llvm::GlobalVariable::GeneralDynamicTLSModel;
281 case CodeGenOptions::LocalDynamicTLSModel:
282 return llvm::GlobalVariable::LocalDynamicTLSModel;
283 case CodeGenOptions::InitialExecTLSModel:
284 return llvm::GlobalVariable::InitialExecTLSModel;
285 case CodeGenOptions::LocalExecTLSModel:
286 return llvm::GlobalVariable::LocalExecTLSModel;
287 }
288 llvm_unreachable("Invalid TLS model!");
289}
290
291void CodeGenModule::setTLSMode(llvm::GlobalVariable *GV,
292 const VarDecl &D) const {
293 assert(D.isThreadSpecified() && "setting TLS mode on non-TLS var!");
294
295 llvm::GlobalVariable::ThreadLocalMode TLM;
Douglas Gregor4cdad312012-10-23 20:05:01 +0000296 TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel());
Hans Wennborgde981f32012-06-28 08:01:44 +0000297
298 // Override the TLS model if it is explicitly specified.
299 if (D.hasAttr<TLSModelAttr>()) {
300 const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>();
301 TLM = GetLLVMTLSModel(Attr->getModel());
302 }
303
304 GV->setThreadLocalMode(TLM);
305}
306
John McCallcbfe5022010-08-04 08:34:44 +0000307/// Set the symbol visibility of type information (vtable and RTTI)
308/// associated with the given type.
309void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV,
310 const CXXRecordDecl *RD,
Anders Carlssonfa2e99f2011-01-29 20:24:48 +0000311 TypeVisibilityKind TVK) const {
Anders Carlsson0ffeaad2011-01-29 19:39:23 +0000312 setGlobalVisibility(GV, RD);
John McCallcbfe5022010-08-04 08:34:44 +0000313
John McCall279b5eb2010-08-12 23:36:15 +0000314 if (!CodeGenOpts.HiddenWeakVTables)
315 return;
316
Anders Carlsson9a86a132011-01-29 20:36:11 +0000317 // We never want to drop the visibility for RTTI names.
318 if (TVK == TVK_ForRTTIName)
319 return;
320
John McCallcbfe5022010-08-04 08:34:44 +0000321 // We want to drop the visibility to hidden for weak type symbols.
322 // This isn't possible if there might be unresolved references
323 // elsewhere that rely on this symbol being visible.
324
John McCall7a536902010-08-05 20:39:18 +0000325 // This should be kept roughly in sync with setThunkVisibility
326 // in CGVTables.cpp.
327
John McCallcbfe5022010-08-04 08:34:44 +0000328 // Preconditions.
Anders Carlssonf502d932011-01-24 00:46:19 +0000329 if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage ||
John McCallcbfe5022010-08-04 08:34:44 +0000330 GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
331 return;
332
333 // Don't override an explicit visibility attribute.
Douglas Gregor4421d2b2011-03-26 12:10:19 +0000334 if (RD->getExplicitVisibility())
John McCallcbfe5022010-08-04 08:34:44 +0000335 return;
336
337 switch (RD->getTemplateSpecializationKind()) {
338 // We have to disable the optimization if this is an EI definition
339 // because there might be EI declarations in other shared objects.
340 case TSK_ExplicitInstantiationDefinition:
341 case TSK_ExplicitInstantiationDeclaration:
342 return;
343
John McCall7a536902010-08-05 20:39:18 +0000344 // Every use of a non-template class's type information has to emit it.
John McCallcbfe5022010-08-04 08:34:44 +0000345 case TSK_Undeclared:
346 break;
347
John McCall7a536902010-08-05 20:39:18 +0000348 // In theory, implicit instantiations can ignore the possibility of
349 // an explicit instantiation declaration because there necessarily
350 // must be an EI definition somewhere with default visibility. In
351 // practice, it's possible to have an explicit instantiation for
352 // an arbitrary template class, and linkers aren't necessarily able
353 // to deal with mixed-visibility symbols.
354 case TSK_ExplicitSpecialization:
John McCallcbfe5022010-08-04 08:34:44 +0000355 case TSK_ImplicitInstantiation:
Douglas Gregoraafd1112012-10-24 14:11:55 +0000356 return;
John McCallcbfe5022010-08-04 08:34:44 +0000357 }
358
359 // If there's a key function, there may be translation units
360 // that don't have the key function's definition. But ignore
361 // this if we're emitting RTTI under -fno-rtti.
David Blaikie4e4d0842012-03-11 07:00:24 +0000362 if (!(TVK != TVK_ForRTTI) || LangOpts.RTTI) {
John McCallcbfe5022010-08-04 08:34:44 +0000363 if (Context.getKeyFunction(RD))
364 return;
Anders Carlssonfa2e99f2011-01-29 20:24:48 +0000365 }
John McCallcbfe5022010-08-04 08:34:44 +0000366
367 // Otherwise, drop the visibility to hidden.
368 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Rafael Espindolab1c65ff2011-01-11 21:44:37 +0000369 GV->setUnnamedAddr(true);
John McCallcbfe5022010-08-04 08:34:44 +0000370}
371
Chris Lattner5f9e2722011-07-23 10:55:15 +0000372StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
Anders Carlsson793a9902010-06-22 16:05:32 +0000373 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
374
Chris Lattner5f9e2722011-07-23 10:55:15 +0000375 StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()];
Anders Carlsson793a9902010-06-22 16:05:32 +0000376 if (!Str.empty())
377 return Str;
378
John McCall4c40d982010-08-31 07:33:07 +0000379 if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
Anders Carlsson793a9902010-06-22 16:05:32 +0000380 IdentifierInfo *II = ND->getIdentifier();
381 assert(II && "Attempt to mangle unnamed decl.");
382
383 Str = II->getName();
384 return Str;
385 }
386
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000387 SmallString<256> Buffer;
Rafael Espindolac4850c22011-02-10 23:59:36 +0000388 llvm::raw_svector_ostream Out(Buffer);
Anders Carlsson793a9902010-06-22 16:05:32 +0000389 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000390 getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000391 else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000392 getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000393 else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND))
Fariborz Jahanian4904bf42012-06-26 16:06:38 +0000394 getCXXABI().getMangleContext().mangleBlock(BD, Out,
395 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()));
Anders Carlsson793a9902010-06-22 16:05:32 +0000396 else
Rafael Espindolac4850c22011-02-10 23:59:36 +0000397 getCXXABI().getMangleContext().mangleName(ND, Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000398
399 // Allocate space for the mangled name.
Rafael Espindolac4850c22011-02-10 23:59:36 +0000400 Out.flush();
Anders Carlsson793a9902010-06-22 16:05:32 +0000401 size_t Length = Buffer.size();
402 char *Name = MangledNamesAllocator.Allocate<char>(Length);
403 std::copy(Buffer.begin(), Buffer.end(), Name);
404
Chris Lattner5f9e2722011-07-23 10:55:15 +0000405 Str = StringRef(Name, Length);
Anders Carlsson793a9902010-06-22 16:05:32 +0000406
407 return Str;
408}
409
Peter Collingbourne14110472011-01-13 18:57:25 +0000410void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer,
411 const BlockDecl *BD) {
412 MangleContext &MangleCtx = getCXXABI().getMangleContext();
413 const Decl *D = GD.getDecl();
Rafael Espindolac4850c22011-02-10 23:59:36 +0000414 llvm::raw_svector_ostream Out(Buffer.getBuffer());
Peter Collingbourne14110472011-01-13 18:57:25 +0000415 if (D == 0)
Fariborz Jahanian4904bf42012-06-26 16:06:38 +0000416 MangleCtx.mangleGlobalBlock(BD,
417 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
Peter Collingbourne14110472011-01-13 18:57:25 +0000418 else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000419 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
Peter Collingbourne14110472011-01-13 18:57:25 +0000420 else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000421 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
Peter Collingbourne14110472011-01-13 18:57:25 +0000422 else
Rafael Espindolac4850c22011-02-10 23:59:36 +0000423 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
Anders Carlsson9a8822b2010-06-09 02:36:32 +0000424}
425
Chris Lattner5f9e2722011-07-23 10:55:15 +0000426llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
John McCallf746aa62010-03-19 23:29:14 +0000427 return getModule().getNamedValue(Name);
Douglas Gregor5f2bfd42009-02-13 00:10:09 +0000428}
429
Chris Lattner6d397602008-03-14 17:18:18 +0000430/// AddGlobalCtor - Add a function to the list that will be called before
431/// main() runs.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000432void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
Daniel Dunbar49988882009-01-13 02:25:00 +0000433 // FIXME: Type coercion of void()* types.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000434 GlobalCtors.push_back(std::make_pair(Ctor, Priority));
Chris Lattner6d397602008-03-14 17:18:18 +0000435}
436
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000437/// AddGlobalDtor - Add a function to the list that will be called
438/// when the module is unloaded.
439void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
Daniel Dunbar49988882009-01-13 02:25:00 +0000440 // FIXME: Type coercion of void()* types.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000441 GlobalDtors.push_back(std::make_pair(Dtor, Priority));
442}
443
444void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
445 // Ctor function type is void()*.
John McCall0774cb82011-05-15 01:53:33 +0000446 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000447 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000448
449 // Get the type of a ctor entry, { i32, void ()* }.
Chris Lattnerc5cbb902011-06-20 04:01:35 +0000450 llvm::StructType *CtorStructTy =
Chris Lattner8b418682012-02-07 00:39:47 +0000451 llvm::StructType::get(Int32Ty, llvm::PointerType::getUnqual(CtorFTy), NULL);
Chris Lattner6d397602008-03-14 17:18:18 +0000452
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000453 // Construct the constructor and destructor arrays.
Chris Lattner0b239712012-02-06 22:16:34 +0000454 SmallVector<llvm::Constant*, 8> Ctors;
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000455 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
Chris Lattner0b239712012-02-06 22:16:34 +0000456 llvm::Constant *S[] = {
457 llvm::ConstantInt::get(Int32Ty, I->second, false),
458 llvm::ConstantExpr::getBitCast(I->first, CtorPFTy)
459 };
Owen Anderson08e25242009-07-27 22:29:56 +0000460 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
Chris Lattner6d397602008-03-14 17:18:18 +0000461 }
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000462
463 if (!Ctors.empty()) {
Owen Anderson96e0fc72009-07-29 22:16:19 +0000464 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
Owen Anderson1c431b32009-07-08 19:05:04 +0000465 new llvm::GlobalVariable(TheModule, AT, false,
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000466 llvm::GlobalValue::AppendingLinkage,
Owen Anderson7db6d832009-07-28 18:33:04 +0000467 llvm::ConstantArray::get(AT, Ctors),
Owen Anderson1c431b32009-07-08 19:05:04 +0000468 GlobalName);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000469 }
Chris Lattner6d397602008-03-14 17:18:18 +0000470}
471
John McCalld46f9852010-02-19 01:32:20 +0000472llvm::GlobalValue::LinkageTypes
473CodeGenModule::getFunctionLinkage(const FunctionDecl *D) {
Argyrios Kyrtzidis90e99a82010-07-29 18:15:58 +0000474 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000475
Chris Lattnerf81530652010-06-30 16:58:07 +0000476 if (Linkage == GVA_Internal)
John McCalld46f9852010-02-19 01:32:20 +0000477 return llvm::Function::InternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000478
479 if (D->hasAttr<DLLExportAttr>())
John McCalld46f9852010-02-19 01:32:20 +0000480 return llvm::Function::DLLExportLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000481
482 if (D->hasAttr<WeakAttr>())
John McCalld46f9852010-02-19 01:32:20 +0000483 return llvm::Function::WeakAnyLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000484
485 // In C99 mode, 'inline' functions are guaranteed to have a strong
486 // definition somewhere else, so we can use available_externally linkage.
487 if (Linkage == GVA_C99Inline)
Fariborz Jahanianfd0f89d2011-02-04 00:08:13 +0000488 return llvm::Function::AvailableExternallyLinkage;
John McCall5584d912011-09-19 18:05:26 +0000489
490 // Note that Apple's kernel linker doesn't support symbol
491 // coalescing, so we need to avoid linkonce and weak linkages there.
492 // Normally, this means we just map to internal, but for explicit
493 // instantiations we'll map to external.
494
Chris Lattnerf81530652010-06-30 16:58:07 +0000495 // In C++, the compiler has to emit a definition in every translation unit
496 // that references the function. We should use linkonce_odr because
497 // a) if all references in this translation unit are optimized away, we
498 // don't need to codegen it. b) if the function persists, it needs to be
499 // merged with other definitions. c) C++ has the ODR, so we know the
500 // definition is dependable.
501 if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
David Blaikie4e4d0842012-03-11 07:00:24 +0000502 return !Context.getLangOpts().AppleKext
Fariborz Jahanian142f9e92011-02-04 00:01:24 +0000503 ? llvm::Function::LinkOnceODRLinkage
504 : llvm::Function::InternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000505
506 // An explicit instantiation of a template has weak linkage, since
507 // explicit instantiations can occur in multiple translation units
508 // and must all be equivalent. However, we are not allowed to
509 // throw away these explicit instantiations.
510 if (Linkage == GVA_ExplicitTemplateInstantiation)
David Blaikie4e4d0842012-03-11 07:00:24 +0000511 return !Context.getLangOpts().AppleKext
Fariborz Jahanian142f9e92011-02-04 00:01:24 +0000512 ? llvm::Function::WeakODRLinkage
John McCall5584d912011-09-19 18:05:26 +0000513 : llvm::Function::ExternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000514
515 // Otherwise, we have strong external linkage.
516 assert(Linkage == GVA_StrongExternal);
517 return llvm::Function::ExternalLinkage;
John McCalld46f9852010-02-19 01:32:20 +0000518}
Nuno Lopesd4cbda62008-06-08 15:45:52 +0000519
John McCalld46f9852010-02-19 01:32:20 +0000520
521/// SetFunctionDefinitionAttributes - Set attributes for a global.
522///
523/// FIXME: This is currently only done for aliases and functions, but not for
524/// variables (these details are set in EmitGlobalVarDefinition for variables).
525void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
526 llvm::GlobalValue *GV) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000527 SetCommonAttributes(D, GV);
Nuno Lopesd4cbda62008-06-08 15:45:52 +0000528}
529
Daniel Dunbar7dbd8192009-04-14 07:08:30 +0000530void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
Mike Stump1eb44332009-09-09 15:08:12 +0000531 const CGFunctionInfo &Info,
Daniel Dunbar7dbd8192009-04-14 07:08:30 +0000532 llvm::Function *F) {
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000533 unsigned CallingConv;
Devang Patel761d7f72008-09-25 21:02:23 +0000534 AttributeListType AttributeList;
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000535 ConstructAttributeList(Info, D, AttributeList, CallingConv);
Bill Wendlingdd851592012-11-20 05:09:43 +0000536 F->setAttributes(llvm::AttrListPtr::get(getLLVMContext(), AttributeList));
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000537 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000538}
539
John McCalld1e40d52011-10-02 01:16:38 +0000540/// Determines whether the language options require us to model
541/// unwind exceptions. We treat -fexceptions as mandating this
542/// except under the fragile ObjC ABI with only ObjC exceptions
543/// enabled. This means, for example, that C with -fexceptions
544/// enables this.
David Blaikie4e4d0842012-03-11 07:00:24 +0000545static bool hasUnwindExceptions(const LangOptions &LangOpts) {
John McCalld1e40d52011-10-02 01:16:38 +0000546 // If exceptions are completely disabled, obviously this is false.
David Blaikie4e4d0842012-03-11 07:00:24 +0000547 if (!LangOpts.Exceptions) return false;
John McCalld1e40d52011-10-02 01:16:38 +0000548
549 // If C++ exceptions are enabled, this is true.
David Blaikie4e4d0842012-03-11 07:00:24 +0000550 if (LangOpts.CXXExceptions) return true;
John McCalld1e40d52011-10-02 01:16:38 +0000551
552 // If ObjC exceptions are enabled, this depends on the ABI.
David Blaikie4e4d0842012-03-11 07:00:24 +0000553 if (LangOpts.ObjCExceptions) {
David Chisnall11d3f4c2012-07-03 20:49:52 +0000554 return LangOpts.ObjCRuntime.hasUnwindExceptions();
John McCalld1e40d52011-10-02 01:16:38 +0000555 }
556
557 return true;
558}
559
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000560void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
561 llvm::Function *F) {
Rafael Espindolaabca5a12011-05-25 03:44:55 +0000562 if (CodeGenOpts.UnwindTables)
563 F->setHasUWTable();
564
David Blaikie4e4d0842012-03-11 07:00:24 +0000565 if (!hasUnwindExceptions(LangOpts))
Bill Wendlingfac63102012-10-10 03:13:20 +0000566 F->addFnAttr(llvm::Attributes::NoUnwind);
Daniel Dunbaraf668b02008-10-28 00:17:57 +0000567
Eli Friedman2873aee2011-08-22 23:55:33 +0000568 if (D->hasAttr<NakedAttr>()) {
569 // Naked implies noinline: we should not be inlining such functions.
Bill Wendlingfac63102012-10-10 03:13:20 +0000570 F->addFnAttr(llvm::Attributes::Naked);
571 F->addFnAttr(llvm::Attributes::NoInline);
Eli Friedman2873aee2011-08-22 23:55:33 +0000572 }
Daniel Dunbardd0cb222010-09-29 18:20:25 +0000573
Mike Stump1feade82009-08-26 22:31:08 +0000574 if (D->hasAttr<NoInlineAttr>())
Bill Wendlingfac63102012-10-10 03:13:20 +0000575 F->addFnAttr(llvm::Attributes::NoInline);
Mike Stumpf55314d2009-10-05 21:58:44 +0000576
Eli Friedman2873aee2011-08-22 23:55:33 +0000577 // (noinline wins over always_inline, and we can't specify both in IR)
Michael J. Spenceradc6cbf2012-06-18 07:00:48 +0000578 if ((D->hasAttr<AlwaysInlineAttr>() || D->hasAttr<ForceInlineAttr>()) &&
Bill Wendling5c3e4ca2012-10-09 07:45:26 +0000579 !F->getFnAttributes().hasAttribute(llvm::Attributes::NoInline))
Bill Wendlingfac63102012-10-10 03:13:20 +0000580 F->addFnAttr(llvm::Attributes::AlwaysInline);
Eli Friedman2873aee2011-08-22 23:55:33 +0000581
Benjamin Krameree409a92012-05-12 21:10:52 +0000582 // FIXME: Communicate hot and cold attributes to LLVM more directly.
583 if (D->hasAttr<ColdAttr>())
Bill Wendlingfac63102012-10-10 03:13:20 +0000584 F->addFnAttr(llvm::Attributes::OptimizeForSize);
Benjamin Krameree409a92012-05-12 21:10:52 +0000585
Quentin Colombetaee56fa2012-11-01 23:55:47 +0000586 if (D->hasAttr<MinSizeAttr>())
587 F->addFnAttr(llvm::Attributes::MinSize);
588
Rafael Espindolac5f657f2011-01-11 00:26:26 +0000589 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
590 F->setUnnamedAddr(true);
591
Richard Smithef4d5ce2012-09-28 22:46:07 +0000592 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D))
593 if (MD->isVirtual())
594 F->setUnnamedAddr(true);
595
David Blaikie4e4d0842012-03-11 07:00:24 +0000596 if (LangOpts.getStackProtector() == LangOptions::SSPOn)
Bill Wendlingfac63102012-10-10 03:13:20 +0000597 F->addFnAttr(llvm::Attributes::StackProtect);
David Blaikie4e4d0842012-03-11 07:00:24 +0000598 else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
Bill Wendlingfac63102012-10-10 03:13:20 +0000599 F->addFnAttr(llvm::Attributes::StackProtectReq);
Anders Carlssonfd015352009-11-16 16:56:03 +0000600
Richard Smithca1b62a2012-11-05 21:48:12 +0000601 if (LangOpts.SanitizeAddress) {
Alexander Potapenko89651ea2012-02-02 11:49:28 +0000602 // When AddressSanitizer is enabled, set AddressSafety attribute
603 // unless __attribute__((no_address_safety_analysis)) is used.
604 if (!D->hasAttr<NoAddressSafetyAnalysisAttr>())
Bill Wendlingfac63102012-10-10 03:13:20 +0000605 F->addFnAttr(llvm::Attributes::AddressSafety);
Alexander Potapenko89651ea2012-02-02 11:49:28 +0000606 }
607
Sean Huntcf807c42010-08-18 23:23:40 +0000608 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
609 if (alignment)
610 F->setAlignment(alignment);
611
Mike Stumpfb51ddf2009-10-05 22:49:20 +0000612 // C++ ABI requires 2-byte alignment for member functions.
Mike Stumpbd6dbd12009-10-05 23:08:21 +0000613 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
614 F->setAlignment(2);
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000615}
616
Mike Stump1eb44332009-09-09 15:08:12 +0000617void CodeGenModule::SetCommonAttributes(const Decl *D,
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000618 llvm::GlobalValue *GV) {
Anders Carlsson934176f2011-01-29 19:41:00 +0000619 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
620 setGlobalVisibility(GV, ND);
John McCall1fb0caa2010-10-22 21:05:15 +0000621 else
622 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000623
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000624 if (D->hasAttr<UsedAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000625 AddUsedGlobal(GV);
626
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000627 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000628 GV->setSection(SA->getName());
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000629
630 getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000631}
632
Daniel Dunbar0e4f40e2009-04-17 00:48:04 +0000633void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
634 llvm::Function *F,
635 const CGFunctionInfo &FI) {
636 SetLLVMFunctionAttributes(D, FI, F);
637 SetLLVMFunctionAttributesForDefinition(D, F);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000638
639 F->setLinkage(llvm::Function::InternalLinkage);
640
Daniel Dunbar0e4f40e2009-04-17 00:48:04 +0000641 SetCommonAttributes(D, F);
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000642}
643
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000644void CodeGenModule::SetFunctionAttributes(GlobalDecl GD,
Eli Friedmanc6c14d12009-05-26 01:22:57 +0000645 llvm::Function *F,
646 bool IsIncompleteFunction) {
Peter Collingbourne0ac2cf42011-04-06 12:29:04 +0000647 if (unsigned IID = F->getIntrinsicID()) {
648 // If this is an intrinsic function, set the function's attributes
649 // to the intrinsic's attributes.
Bill Wendling50e6b182012-10-15 04:47:45 +0000650 F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(),
651 (llvm::Intrinsic::ID)IID));
Peter Collingbourne0ac2cf42011-04-06 12:29:04 +0000652 return;
653 }
654
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000655 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
656
Eli Friedmanc6c14d12009-05-26 01:22:57 +0000657 if (!IsIncompleteFunction)
John McCallde5d3c72012-02-17 03:33:10 +0000658 SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F);
Mike Stump1eb44332009-09-09 15:08:12 +0000659
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000660 // Only a few attributes are set on declarations; these may later be
661 // overridden by a definition.
Mike Stump1eb44332009-09-09 15:08:12 +0000662
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000663 if (FD->hasAttr<DLLImportAttr>()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000664 F->setLinkage(llvm::Function::DLLImportLinkage);
Mike Stump1eb44332009-09-09 15:08:12 +0000665 } else if (FD->hasAttr<WeakAttr>() ||
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000666 FD->isWeakImported()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000667 // "extern_weak" is overloaded in LLVM; we probably should have
Mike Stump1eb44332009-09-09 15:08:12 +0000668 // separate linkage types for this.
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000669 F->setLinkage(llvm::Function::ExternalWeakLinkage);
670 } else {
Mike Stump1eb44332009-09-09 15:08:12 +0000671 F->setLinkage(llvm::Function::ExternalLinkage);
John McCallaf146032010-10-30 11:50:40 +0000672
673 NamedDecl::LinkageInfo LV = FD->getLinkageAndVisibility();
674 if (LV.linkage() == ExternalLinkage && LV.visibilityExplicit()) {
675 F->setVisibility(GetLLVMVisibility(LV.visibility()));
676 }
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000677 }
678
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000679 if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000680 F->setSection(SA->getName());
Daniel Dunbar219df662008-09-08 23:44:31 +0000681}
682
Daniel Dunbar02698712009-02-13 20:29:50 +0000683void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
Mike Stump1eb44332009-09-09 15:08:12 +0000684 assert(!GV->isDeclaration() &&
Daniel Dunbar02698712009-02-13 20:29:50 +0000685 "Only globals with definition can force usage.");
Chris Lattner35f38a22009-03-31 22:37:52 +0000686 LLVMUsed.push_back(GV);
Daniel Dunbar02698712009-02-13 20:29:50 +0000687}
688
689void CodeGenModule::EmitLLVMUsed() {
690 // Don't create llvm.used if there is no need.
Chris Lattnerad64e022009-07-17 23:57:13 +0000691 if (LLVMUsed.empty())
Daniel Dunbar02698712009-02-13 20:29:50 +0000692 return;
693
Chris Lattner35f38a22009-03-31 22:37:52 +0000694 // Convert LLVMUsed to what ConstantArray needs.
Chris Lattner0b239712012-02-06 22:16:34 +0000695 SmallVector<llvm::Constant*, 8> UsedArray;
Chris Lattner35f38a22009-03-31 22:37:52 +0000696 UsedArray.resize(LLVMUsed.size());
697 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
Mike Stump1eb44332009-09-09 15:08:12 +0000698 UsedArray[i] =
699 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
Chris Lattner0b239712012-02-06 22:16:34 +0000700 Int8PtrTy);
Chris Lattner35f38a22009-03-31 22:37:52 +0000701 }
Mike Stump1eb44332009-09-09 15:08:12 +0000702
Fariborz Jahanianc38e9af2009-06-23 21:47:46 +0000703 if (UsedArray.empty())
704 return;
Chris Lattner0b239712012-02-06 22:16:34 +0000705 llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size());
Mike Stump1eb44332009-09-09 15:08:12 +0000706
707 llvm::GlobalVariable *GV =
708 new llvm::GlobalVariable(getModule(), ATy, false,
Daniel Dunbar02698712009-02-13 20:29:50 +0000709 llvm::GlobalValue::AppendingLinkage,
Owen Anderson7db6d832009-07-28 18:33:04 +0000710 llvm::ConstantArray::get(ATy, UsedArray),
Owen Anderson1c431b32009-07-08 19:05:04 +0000711 "llvm.used");
Daniel Dunbar02698712009-02-13 20:29:50 +0000712
713 GV->setSection("llvm.metadata");
714}
715
716void CodeGenModule::EmitDeferred() {
Chris Lattner67b00522009-03-21 09:44:56 +0000717 // Emit code for any potentially referenced deferred decls. Since a
718 // previously unused static decl may become used during the generation of code
Nick Lewyckydce67a72011-07-18 05:26:13 +0000719 // for a static function, iterate until no changes are made.
Rafael Espindolabbf58bb2010-03-10 02:19:29 +0000720
Anders Carlsson046c2942010-04-17 20:15:18 +0000721 while (!DeferredDeclsToEmit.empty() || !DeferredVTables.empty()) {
722 if (!DeferredVTables.empty()) {
723 const CXXRecordDecl *RD = DeferredVTables.back();
724 DeferredVTables.pop_back();
Charles Davis9ee494f2012-06-23 23:44:00 +0000725 getCXXABI().EmitVTables(RD);
Rafael Espindolabbf58bb2010-03-10 02:19:29 +0000726 continue;
727 }
728
Anders Carlsson2a131fb2009-05-05 04:44:02 +0000729 GlobalDecl D = DeferredDeclsToEmit.back();
Chris Lattner67b00522009-03-21 09:44:56 +0000730 DeferredDeclsToEmit.pop_back();
731
John McCallc76702c2010-05-27 01:45:30 +0000732 // Check to see if we've already emitted this. This is necessary
733 // for a couple of reasons: first, decls can end up in the
734 // deferred-decls queue multiple times, and second, decls can end
735 // up with definitions in unusual ways (e.g. by an extern inline
736 // function acquiring a strong function redefinition). Just
737 // ignore these cases.
738 //
739 // TODO: That said, looking this up multiple times is very wasteful.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000740 StringRef Name = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +0000741 llvm::GlobalValue *CGRef = GetGlobalValue(Name);
Chris Lattner67b00522009-03-21 09:44:56 +0000742 assert(CGRef && "Deferred decl wasn't referenced?");
Mike Stump1eb44332009-09-09 15:08:12 +0000743
Chris Lattner67b00522009-03-21 09:44:56 +0000744 if (!CGRef->isDeclaration())
745 continue;
Mike Stump1eb44332009-09-09 15:08:12 +0000746
John McCallc76702c2010-05-27 01:45:30 +0000747 // GlobalAlias::isDeclaration() defers to the aliasee, but for our
748 // purposes an alias counts as a definition.
749 if (isa<llvm::GlobalAlias>(CGRef))
750 continue;
751
Chris Lattner67b00522009-03-21 09:44:56 +0000752 // Otherwise, emit the definition and move on to the next one.
753 EmitGlobalDefinition(D);
754 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000755}
756
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000757void CodeGenModule::EmitGlobalAnnotations() {
758 if (Annotations.empty())
759 return;
760
761 // Create a new global variable for the ConstantStruct in the Module.
762 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
763 Annotations[0]->getType(), Annotations.size()), Annotations);
764 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(),
765 Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array,
766 "llvm.global.annotations");
767 gv->setSection(AnnotationSection);
768}
769
770llvm::Constant *CodeGenModule::EmitAnnotationString(llvm::StringRef Str) {
771 llvm::StringMap<llvm::Constant*>::iterator i = AnnotationStrings.find(Str);
772 if (i != AnnotationStrings.end())
773 return i->second;
774
775 // Not found yet, create a new global.
Chris Lattner94010692012-02-05 02:30:40 +0000776 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000777 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(),
778 true, llvm::GlobalValue::PrivateLinkage, s, ".str");
779 gv->setSection(AnnotationSection);
780 gv->setUnnamedAddr(true);
781 AnnotationStrings[Str] = gv;
782 return gv;
783}
784
785llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) {
786 SourceManager &SM = getContext().getSourceManager();
787 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
788 if (PLoc.isValid())
789 return EmitAnnotationString(PLoc.getFilename());
790 return EmitAnnotationString(SM.getBufferName(Loc));
791}
792
793llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
794 SourceManager &SM = getContext().getSourceManager();
795 PresumedLoc PLoc = SM.getPresumedLoc(L);
796 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
797 SM.getExpansionLineNumber(L);
798 return llvm::ConstantInt::get(Int32Ty, LineNo);
799}
800
Mike Stump1eb44332009-09-09 15:08:12 +0000801llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000802 const AnnotateAttr *AA,
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000803 SourceLocation L) {
804 // Get the globals for file name, annotation, and the line number.
805 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
806 *UnitGV = EmitAnnotationUnit(L),
807 *LineNoCst = EmitAnnotationLineNo(L);
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000808
Daniel Dunbar57d5cee2009-04-14 22:41:13 +0000809 // Create the ConstantStruct for the global annotation.
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000810 llvm::Constant *Fields[4] = {
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000811 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
812 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
813 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
814 LineNoCst
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000815 };
Chris Lattnerc5cbb902011-06-20 04:01:35 +0000816 return llvm::ConstantStruct::getAnon(Fields);
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000817}
818
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000819void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
820 llvm::GlobalValue *GV) {
821 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
822 // Get the struct elements for these annotations.
823 for (specific_attr_iterator<AnnotateAttr>
824 ai = D->specific_attr_begin<AnnotateAttr>(),
825 ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai)
826 Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation()));
827}
828
Argyrios Kyrtzidisa6d6af32010-07-27 22:37:14 +0000829bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
Argyrios Kyrtzidis90e99a82010-07-29 18:15:58 +0000830 // Never defer when EmitAllDecls is specified.
David Blaikie4e4d0842012-03-11 07:00:24 +0000831 if (LangOpts.EmitAllDecls)
Daniel Dunbar73241df2009-02-13 21:18:01 +0000832 return false;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000833
Argyrios Kyrtzidis4ac7c0b2010-07-29 20:08:05 +0000834 return !getContext().DeclMustBeEmitted(Global);
Daniel Dunbar73241df2009-02-13 21:18:01 +0000835}
836
Nico Weberc5f80462012-10-11 10:13:44 +0000837llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor(
838 const CXXUuidofExpr* E) {
839 // Sema has verified that IIDSource has a __declspec(uuid()), and that its
840 // well-formed.
841 StringRef Uuid;
842 if (E->isTypeOperand())
843 Uuid = CXXUuidofExpr::GetUuidAttrOfType(E->getTypeOperand())->getGuid();
844 else {
845 // Special case: __uuidof(0) means an all-zero GUID.
846 Expr *Op = E->getExprOperand();
847 if (!Op->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
848 Uuid = CXXUuidofExpr::GetUuidAttrOfType(Op->getType())->getGuid();
849 else
850 Uuid = "00000000-0000-0000-0000-000000000000";
851 }
852 std::string Name = "__uuid_" + Uuid.str();
853
854 // Look for an existing global.
855 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
856 return GV;
857
858 llvm::Constant *Init = EmitUuidofInitializer(Uuid, E->getType());
859 assert(Init && "failed to initialize as constant");
860
861 // GUIDs are assumed to be 16 bytes, spread over 4-2-2-8 bytes. However, the
862 // first field is declared as "long", which for many targets is 8 bytes.
863 // Those architectures are not supported. (With the MS abi, long is always 4
864 // bytes.)
865 llvm::Type *GuidType = getTypes().ConvertType(E->getType());
866 if (Init->getType() != GuidType) {
867 DiagnosticsEngine &Diags = getDiags();
868 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
869 "__uuidof codegen is not supported on this architecture");
870 Diags.Report(E->getExprLoc(), DiagID) << E->getSourceRange();
871 Init = llvm::UndefValue::get(GuidType);
872 }
873
874 llvm::GlobalVariable *GV = new llvm::GlobalVariable(getModule(), GuidType,
875 /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, Init, Name);
876 GV->setUnnamedAddr(true);
877 return GV;
878}
879
Rafael Espindola6a836702010-03-04 18:17:24 +0000880llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
881 const AliasAttr *AA = VD->getAttr<AliasAttr>();
882 assert(AA && "No alias?");
883
Chris Lattner2acc6e32011-07-18 04:24:23 +0000884 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
Rafael Espindola6a836702010-03-04 18:17:24 +0000885
Rafael Espindola6a836702010-03-04 18:17:24 +0000886 // See if there is already something with the target's name in the module.
John McCallf746aa62010-03-19 23:29:14 +0000887 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
Joerg Sonnenberger4695f912012-10-16 17:45:27 +0000888 if (Entry) {
889 unsigned AS = getContext().getTargetAddressSpace(VD->getType());
890 return llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
891 }
Rafael Espindola6a836702010-03-04 18:17:24 +0000892
893 llvm::Constant *Aliasee;
894 if (isa<llvm::FunctionType>(DeclTy))
Alex Rosenbergc857ce82012-10-05 23:12:53 +0000895 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
896 GlobalDecl(cast<FunctionDecl>(VD)),
Anders Carlsson1faa89f2011-02-05 04:35:53 +0000897 /*ForVTable=*/false);
Rafael Espindola6a836702010-03-04 18:17:24 +0000898 else
John McCallf746aa62010-03-19 23:29:14 +0000899 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Rafael Espindola6a836702010-03-04 18:17:24 +0000900 llvm::PointerType::getUnqual(DeclTy), 0);
Joerg Sonnenberger4695f912012-10-16 17:45:27 +0000901
902 llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee);
903 F->setLinkage(llvm::Function::ExternalWeakLinkage);
904 WeakRefReferences.insert(F);
Rafael Espindola6a836702010-03-04 18:17:24 +0000905
906 return Aliasee;
907}
908
Chris Lattnerb4880ba2009-05-12 21:21:08 +0000909void CodeGenModule::EmitGlobal(GlobalDecl GD) {
Anders Carlsson4a6835e2009-09-10 23:38:47 +0000910 const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +0000911
Rafael Espindola6a836702010-03-04 18:17:24 +0000912 // Weak references don't produce any output by themselves.
913 if (Global->hasAttr<WeakRefAttr>())
914 return;
915
Chris Lattnerbd532712009-03-22 21:47:11 +0000916 // If this is an alias definition (which otherwise looks like a declaration)
917 // emit it now.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000918 if (Global->hasAttr<AliasAttr>())
John McCallf746aa62010-03-19 23:29:14 +0000919 return EmitAliasDefinition(GD);
Daniel Dunbar219df662008-09-08 23:44:31 +0000920
Peter Collingbourned51e43a2011-10-06 18:29:46 +0000921 // If this is CUDA, be selective about which declarations we emit.
David Blaikie4e4d0842012-03-11 07:00:24 +0000922 if (LangOpts.CUDA) {
Peter Collingbourned51e43a2011-10-06 18:29:46 +0000923 if (CodeGenOpts.CUDAIsDevice) {
924 if (!Global->hasAttr<CUDADeviceAttr>() &&
925 !Global->hasAttr<CUDAGlobalAttr>() &&
926 !Global->hasAttr<CUDAConstantAttr>() &&
927 !Global->hasAttr<CUDASharedAttr>())
928 return;
929 } else {
930 if (!Global->hasAttr<CUDAHostAttr>() && (
931 Global->hasAttr<CUDADeviceAttr>() ||
932 Global->hasAttr<CUDAConstantAttr>() ||
933 Global->hasAttr<CUDASharedAttr>()))
934 return;
935 }
936 }
937
Chris Lattner67b00522009-03-21 09:44:56 +0000938 // Ignore declarations, they will be emitted on their first use.
Daniel Dunbar5e1e1f92009-03-19 08:27:24 +0000939 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
Daniel Dunbar73241df2009-02-13 21:18:01 +0000940 // Forward declarations are emitted lazily on first use.
Nick Lewyckydce67a72011-07-18 05:26:13 +0000941 if (!FD->doesThisDeclarationHaveABody()) {
942 if (!FD->doesDeclarationForceExternallyVisibleDefinition())
943 return;
944
945 const FunctionDecl *InlineDefinition = 0;
946 FD->getBody(InlineDefinition);
947
Chris Lattner5f9e2722011-07-23 10:55:15 +0000948 StringRef MangledName = getMangledName(GD);
Benjamin Kramer7e423922012-03-24 18:22:12 +0000949 DeferredDecls.erase(MangledName);
Nick Lewyckydce67a72011-07-18 05:26:13 +0000950 EmitGlobalDefinition(InlineDefinition);
Daniel Dunbar73241df2009-02-13 21:18:01 +0000951 return;
Nick Lewyckydce67a72011-07-18 05:26:13 +0000952 }
Daniel Dunbar02698712009-02-13 20:29:50 +0000953 } else {
954 const VarDecl *VD = cast<VarDecl>(Global);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000955 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
956
Douglas Gregora9a55c02010-02-06 05:15:45 +0000957 if (VD->isThisDeclarationADefinition() != VarDecl::Definition)
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000958 return;
Nate Begeman4c13b7a2008-04-20 06:29:50 +0000959 }
960
Chris Lattner67b00522009-03-21 09:44:56 +0000961 // Defer code generation when possible if this is a static definition, inline
962 // function etc. These we only want to emit if they are used.
Chris Lattner4357a822010-04-13 17:39:09 +0000963 if (!MayDeferGeneration(Global)) {
964 // Emit the definition if it can't be deferred.
965 EmitGlobalDefinition(GD);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000966 return;
967 }
John McCallbf40cb52010-07-15 23:40:35 +0000968
969 // If we're deferring emission of a C++ variable with an
970 // initializer, remember the order in which it appeared in the file.
David Blaikie4e4d0842012-03-11 07:00:24 +0000971 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
John McCallbf40cb52010-07-15 23:40:35 +0000972 cast<VarDecl>(Global)->hasInit()) {
973 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
974 CXXGlobalInits.push_back(0);
975 }
Chris Lattner4357a822010-04-13 17:39:09 +0000976
977 // If the value has already been used, add it directly to the
978 // DeferredDeclsToEmit list.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000979 StringRef MangledName = getMangledName(GD);
Chris Lattner4357a822010-04-13 17:39:09 +0000980 if (GetGlobalValue(MangledName))
981 DeferredDeclsToEmit.push_back(GD);
982 else {
983 // Otherwise, remember that we saw a deferred decl with this name. The
984 // first use of the mangled name will cause it to move into
985 // DeferredDeclsToEmit.
986 DeferredDecls[MangledName] = GD;
987 }
Nate Begeman4c13b7a2008-04-20 06:29:50 +0000988}
989
Rafael Espindolaa411d2f2011-10-26 20:41:06 +0000990namespace {
991 struct FunctionIsDirectlyRecursive :
992 public RecursiveASTVisitor<FunctionIsDirectlyRecursive> {
993 const StringRef Name;
Rafael Espindolabcf6b982011-12-19 14:41:01 +0000994 const Builtin::Context &BI;
Rafael Espindolaa411d2f2011-10-26 20:41:06 +0000995 bool Result;
Rafael Espindolabcf6b982011-12-19 14:41:01 +0000996 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) :
997 Name(N), BI(C), Result(false) {
Rafael Espindolaa411d2f2011-10-26 20:41:06 +0000998 }
999 typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base;
1000
1001 bool TraverseCallExpr(CallExpr *E) {
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001002 const FunctionDecl *FD = E->getDirectCallee();
1003 if (!FD)
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001004 return true;
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001005 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1006 if (Attr && Name == Attr->getLabel()) {
1007 Result = true;
1008 return false;
1009 }
1010 unsigned BuiltinID = FD->getBuiltinID();
1011 if (!BuiltinID)
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001012 return true;
Nick Lewyckyf6b56372012-01-18 03:41:19 +00001013 StringRef BuiltinName = BI.GetName(BuiltinID);
1014 if (BuiltinName.startswith("__builtin_") &&
1015 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001016 Result = true;
1017 return false;
1018 }
1019 return true;
1020 }
1021 };
1022}
1023
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001024// isTriviallyRecursive - Check if this function calls another
1025// decl that, because of the asm attribute or the other decl being a builtin,
1026// ends up pointing to itself.
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001027bool
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001028CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
1029 StringRef Name;
1030 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
Nick Lewycky22afacc2012-01-18 01:50:13 +00001031 // asm labels are a special kind of mangling we have to support.
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001032 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1033 if (!Attr)
1034 return false;
1035 Name = Attr->getLabel();
1036 } else {
1037 Name = FD->getName();
1038 }
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001039
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001040 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
1041 Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD));
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001042 return Walker.Result;
1043}
1044
1045bool
1046CodeGenModule::shouldEmitFunction(const FunctionDecl *F) {
1047 if (getFunctionLinkage(F) != llvm::Function::AvailableExternallyLinkage)
1048 return true;
Rafael Espindolacc4889f2011-10-28 20:43:56 +00001049 if (CodeGenOpts.OptimizationLevel == 0 &&
Michael J. Spenceradc6cbf2012-06-18 07:00:48 +00001050 !F->hasAttr<AlwaysInlineAttr>() && !F->hasAttr<ForceInlineAttr>())
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001051 return false;
1052 // PR9614. Avoid cases where the source code is lying to us. An available
1053 // externally function should have an equivalent function somewhere else,
1054 // but a function that calls itself is clearly not equivalent to the real
1055 // implementation.
1056 // This happens in glibc's btowc and in some configure checks.
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001057 return !isTriviallyRecursive(F);
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001058}
1059
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001060void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
Anders Carlsson4a6835e2009-09-10 23:38:47 +00001061 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00001062
Dan Gohmancb421fa2010-04-19 16:39:44 +00001063 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
Anders Carlsson8e2efcc2009-10-27 14:32:27 +00001064 Context.getSourceManager(),
1065 "Generating code for declaration");
1066
Douglas Gregor44eac332010-07-13 06:02:28 +00001067 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
1068 // At -O0, don't generate IR for functions with available_externally
1069 // linkage.
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001070 if (!shouldEmitFunction(Function))
Douglas Gregor44eac332010-07-13 06:02:28 +00001071 return;
Anders Carlsson7270ee42010-03-23 04:31:31 +00001072
Douglas Gregor44eac332010-07-13 06:02:28 +00001073 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
Eli Friedman7dcdf5b2011-05-06 17:27:27 +00001074 // Make sure to emit the definition(s) before we emit the thunks.
1075 // This is necessary for the generation of certain thunks.
1076 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
1077 EmitCXXConstructor(CD, GD.getCtorType());
1078 else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method))
1079 EmitCXXDestructor(DD, GD.getDtorType());
1080 else
1081 EmitGlobalFunctionDefinition(GD);
1082
Douglas Gregor44eac332010-07-13 06:02:28 +00001083 if (Method->isVirtual())
1084 getVTables().EmitThunks(GD);
1085
Eli Friedman7dcdf5b2011-05-06 17:27:27 +00001086 return;
Douglas Gregor44eac332010-07-13 06:02:28 +00001087 }
Chris Lattnerb5e81562010-04-13 17:57:11 +00001088
Chris Lattnerb5e81562010-04-13 17:57:11 +00001089 return EmitGlobalFunctionDefinition(GD);
Douglas Gregor44eac332010-07-13 06:02:28 +00001090 }
Chris Lattnerb5e81562010-04-13 17:57:11 +00001091
1092 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
1093 return EmitGlobalVarDefinition(VD);
Chris Lattner4357a822010-04-13 17:39:09 +00001094
David Blaikieb219cfc2011-09-23 05:06:16 +00001095 llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001096}
1097
Chris Lattner74391b42009-03-22 21:03:39 +00001098/// GetOrCreateLLVMFunction - If the specified mangled name is not in the
1099/// module, create and return an llvm Function with the specified type. If there
1100/// is something in the module with the specified name, return it potentially
1101/// bitcasted to the right type.
1102///
1103/// If D is non-null, it specifies a decl that correspond to this. This is used
1104/// to set the attributes on the function when it is first created.
John McCallf746aa62010-03-19 23:29:14 +00001105llvm::Constant *
Chris Lattner5f9e2722011-07-23 10:55:15 +00001106CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001107 llvm::Type *Ty,
John McCallf85e1932011-06-15 23:02:42 +00001108 GlobalDecl D, bool ForVTable,
1109 llvm::Attributes ExtraAttrs) {
Chris Lattner0558e792009-03-21 09:25:43 +00001110 // Lookup the entry, lazily creating it if necessary.
John McCallf746aa62010-03-19 23:29:14 +00001111 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner0558e792009-03-21 09:25:43 +00001112 if (Entry) {
Benjamin Kramerd48bcb22012-08-22 15:37:55 +00001113 if (WeakRefReferences.erase(Entry)) {
Rafael Espindola6a836702010-03-04 18:17:24 +00001114 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl());
1115 if (FD && !FD->hasAttr<WeakAttr>())
Anders Carlsson7270ee42010-03-23 04:31:31 +00001116 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola6a836702010-03-04 18:17:24 +00001117 }
1118
Chris Lattner0558e792009-03-21 09:25:43 +00001119 if (Entry->getType()->getElementType() == Ty)
1120 return Entry;
Mike Stump1eb44332009-09-09 15:08:12 +00001121
Chris Lattner0558e792009-03-21 09:25:43 +00001122 // Make sure the result is of the correct type.
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001123 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
Chris Lattner0558e792009-03-21 09:25:43 +00001124 }
Mike Stump1eb44332009-09-09 15:08:12 +00001125
Eli Friedman654ad402009-11-09 05:07:37 +00001126 // This function doesn't have a complete type (for example, the return
1127 // type is an incomplete struct). Use a fake type instead, and make
1128 // sure not to try to set attributes.
1129 bool IsIncompleteFunction = false;
John McCall784f2112010-04-28 00:00:30 +00001130
Chris Lattner2acc6e32011-07-18 04:24:23 +00001131 llvm::FunctionType *FTy;
John McCall784f2112010-04-28 00:00:30 +00001132 if (isa<llvm::FunctionType>(Ty)) {
1133 FTy = cast<llvm::FunctionType>(Ty);
1134 } else {
John McCall0774cb82011-05-15 01:53:33 +00001135 FTy = llvm::FunctionType::get(VoidTy, false);
Eli Friedman654ad402009-11-09 05:07:37 +00001136 IsIncompleteFunction = true;
1137 }
Chris Lattnerbcaedae2010-06-30 19:14:05 +00001138
John McCall784f2112010-04-28 00:00:30 +00001139 llvm::Function *F = llvm::Function::Create(FTy,
Eli Friedman654ad402009-11-09 05:07:37 +00001140 llvm::Function::ExternalLinkage,
John McCallf746aa62010-03-19 23:29:14 +00001141 MangledName, &getModule());
1142 assert(F->getName() == MangledName && "name was uniqued!");
Eli Friedman654ad402009-11-09 05:07:37 +00001143 if (D.getDecl())
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +00001144 SetFunctionAttributes(D, F, IsIncompleteFunction);
Bill Wendlingfac63102012-10-10 03:13:20 +00001145 if (ExtraAttrs.hasAttributes())
Bill Wendling75d37b42012-10-15 07:31:59 +00001146 F->addAttribute(llvm::AttrListPtr::FunctionIndex, ExtraAttrs);
Eli Friedman654ad402009-11-09 05:07:37 +00001147
Chris Lattner67b00522009-03-21 09:44:56 +00001148 // This is the first use or definition of a mangled name. If there is a
1149 // deferred decl with this name, remember that we need to emit it at the end
1150 // of the file.
John McCallf746aa62010-03-19 23:29:14 +00001151 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner67b00522009-03-21 09:44:56 +00001152 if (DDI != DeferredDecls.end()) {
1153 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1154 // list, and remove it from DeferredDecls (since we don't need it anymore).
1155 DeferredDeclsToEmit.push_back(DDI->second);
1156 DeferredDecls.erase(DDI);
John McCallbfdcdc82010-12-15 04:00:32 +00001157
1158 // Otherwise, there are cases we have to worry about where we're
1159 // using a declaration for which we must emit a definition but where
1160 // we might not find a top-level definition:
1161 // - member functions defined inline in their classes
1162 // - friend functions defined inline in some class
1163 // - special member functions with implicit definitions
1164 // If we ever change our AST traversal to walk into class methods,
1165 // this will be unnecessary.
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001166 //
1167 // We also don't emit a definition for a function if it's going to be an entry
1168 // in a vtable, unless it's already marked as used.
David Blaikie4e4d0842012-03-11 07:00:24 +00001169 } else if (getLangOpts().CPlusPlus && D.getDecl()) {
John McCallbfdcdc82010-12-15 04:00:32 +00001170 // Look for a declaration that's lexically in a record.
1171 const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl());
Eli Friedmanb135f0f2012-07-02 21:05:30 +00001172 FD = FD->getMostRecentDecl();
John McCallbfdcdc82010-12-15 04:00:32 +00001173 do {
1174 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001175 if (FD->isImplicit() && !ForVTable) {
John McCallbfdcdc82010-12-15 04:00:32 +00001176 assert(FD->isUsed() && "Sema didn't mark implicit function as used!");
Douglas Gregora29bf412011-02-09 02:03:05 +00001177 DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
John McCallbfdcdc82010-12-15 04:00:32 +00001178 break;
Sean Hunt10620eb2011-05-06 20:44:56 +00001179 } else if (FD->doesThisDeclarationHaveABody()) {
Douglas Gregora29bf412011-02-09 02:03:05 +00001180 DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
John McCallbfdcdc82010-12-15 04:00:32 +00001181 break;
1182 }
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +00001183 }
Douglas Gregoref96ee02012-01-14 16:38:05 +00001184 FD = FD->getPreviousDecl();
John McCallbfdcdc82010-12-15 04:00:32 +00001185 } while (FD);
Chris Lattner67b00522009-03-21 09:44:56 +00001186 }
Mike Stump1eb44332009-09-09 15:08:12 +00001187
John McCall784f2112010-04-28 00:00:30 +00001188 // Make sure the result is of the requested type.
1189 if (!IsIncompleteFunction) {
1190 assert(F->getType()->getElementType() == Ty);
1191 return F;
1192 }
1193
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001194 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
John McCall784f2112010-04-28 00:00:30 +00001195 return llvm::ConstantExpr::getBitCast(F, PTy);
Chris Lattner0558e792009-03-21 09:25:43 +00001196}
1197
Chris Lattner74391b42009-03-22 21:03:39 +00001198/// GetAddrOfFunction - Return the address of the given function. If Ty is
1199/// non-null, then this function will use the specified type if it has to
1200/// create it (this occurs when we see a definition of the function).
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001201llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001202 llvm::Type *Ty,
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001203 bool ForVTable) {
Chris Lattner74391b42009-03-22 21:03:39 +00001204 // If there was no specific requested type, just convert it now.
1205 if (!Ty)
Anders Carlsson4a6835e2009-09-10 23:38:47 +00001206 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
Chris Lattnerbcaedae2010-06-30 19:14:05 +00001207
Chris Lattner5f9e2722011-07-23 10:55:15 +00001208 StringRef MangledName = getMangledName(GD);
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001209 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable);
Chris Lattner74391b42009-03-22 21:03:39 +00001210}
Eli Friedman77ba7082008-05-30 19:50:47 +00001211
Chris Lattner74391b42009-03-22 21:03:39 +00001212/// CreateRuntimeFunction - Create a new runtime function with the specified
1213/// type and name.
1214llvm::Constant *
Chris Lattner2acc6e32011-07-18 04:24:23 +00001215CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001216 StringRef Name,
John McCallf85e1932011-06-15 23:02:42 +00001217 llvm::Attributes ExtraAttrs) {
1218 return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
1219 ExtraAttrs);
Chris Lattner74391b42009-03-22 21:03:39 +00001220}
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001221
Richard Smitha9b21d22012-02-17 06:48:11 +00001222/// isTypeConstant - Determine whether an object of this type can be emitted
1223/// as a constant.
1224///
1225/// If ExcludeCtor is true, the duration when the object's constructor runs
1226/// will not be considered. The caller will need to verify that the object is
1227/// not written to during its construction.
1228bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
1229 if (!Ty.isConstant(Context) && !Ty->isReferenceType())
Eli Friedman20e098b2009-12-11 21:23:03 +00001230 return false;
Richard Smitha9b21d22012-02-17 06:48:11 +00001231
David Blaikie4e4d0842012-03-11 07:00:24 +00001232 if (Context.getLangOpts().CPlusPlus) {
Richard Smitha9b21d22012-02-17 06:48:11 +00001233 if (const CXXRecordDecl *Record
1234 = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
1235 return ExcludeCtor && !Record->hasMutableFields() &&
1236 Record->hasTrivialDestructor();
Eli Friedman20e098b2009-12-11 21:23:03 +00001237 }
Richard Smitha9b21d22012-02-17 06:48:11 +00001238
Eli Friedman20e098b2009-12-11 21:23:03 +00001239 return true;
1240}
1241
Chris Lattner74391b42009-03-22 21:03:39 +00001242/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
1243/// create and return an llvm GlobalVariable with the specified type. If there
1244/// is something in the module with the specified name, return it potentially
1245/// bitcasted to the right type.
1246///
1247/// If D is non-null, it specifies a decl that correspond to this. This is used
1248/// to set the attributes on the global when it is first created.
John McCallf746aa62010-03-19 23:29:14 +00001249llvm::Constant *
Chris Lattner5f9e2722011-07-23 10:55:15 +00001250CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001251 llvm::PointerType *Ty,
Rafael Espindolac532b502011-01-18 21:07:57 +00001252 const VarDecl *D,
1253 bool UnnamedAddr) {
Daniel Dunbar3c827a72008-08-05 23:31:02 +00001254 // Lookup the entry, lazily creating it if necessary.
John McCallf746aa62010-03-19 23:29:14 +00001255 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner99b53612009-03-21 08:03:33 +00001256 if (Entry) {
Benjamin Kramerd48bcb22012-08-22 15:37:55 +00001257 if (WeakRefReferences.erase(Entry)) {
Rafael Espindola6a836702010-03-04 18:17:24 +00001258 if (D && !D->hasAttr<WeakAttr>())
Anders Carlsson7270ee42010-03-23 04:31:31 +00001259 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola6a836702010-03-04 18:17:24 +00001260 }
1261
Rafael Espindolac532b502011-01-18 21:07:57 +00001262 if (UnnamedAddr)
1263 Entry->setUnnamedAddr(true);
1264
Chris Lattner74391b42009-03-22 21:03:39 +00001265 if (Entry->getType() == Ty)
Chris Lattner570585c2009-03-21 09:16:30 +00001266 return Entry;
Mike Stump1eb44332009-09-09 15:08:12 +00001267
Chris Lattner99b53612009-03-21 08:03:33 +00001268 // Make sure the result is of the correct type.
Owen Anderson3c4972d2009-07-29 18:54:39 +00001269 return llvm::ConstantExpr::getBitCast(Entry, Ty);
Daniel Dunbar49988882009-01-13 02:25:00 +00001270 }
Mike Stump1eb44332009-09-09 15:08:12 +00001271
Chris Lattner67b00522009-03-21 09:44:56 +00001272 // This is the first use or definition of a mangled name. If there is a
1273 // deferred decl with this name, remember that we need to emit it at the end
1274 // of the file.
John McCallf746aa62010-03-19 23:29:14 +00001275 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner67b00522009-03-21 09:44:56 +00001276 if (DDI != DeferredDecls.end()) {
1277 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1278 // list, and remove it from DeferredDecls (since we don't need it anymore).
1279 DeferredDeclsToEmit.push_back(DDI->second);
1280 DeferredDecls.erase(DDI);
1281 }
Mike Stump1eb44332009-09-09 15:08:12 +00001282
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00001283 unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace());
Mike Stump1eb44332009-09-09 15:08:12 +00001284 llvm::GlobalVariable *GV =
1285 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
Chris Lattner99b53612009-03-21 08:03:33 +00001286 llvm::GlobalValue::ExternalLinkage,
John McCallf746aa62010-03-19 23:29:14 +00001287 0, MangledName, 0,
Hans Wennborg5e2d5de2012-06-23 11:51:46 +00001288 llvm::GlobalVariable::NotThreadLocal, AddrSpace);
Chris Lattner99b53612009-03-21 08:03:33 +00001289
1290 // Handle things which are present even on external declarations.
Chris Lattner74391b42009-03-22 21:03:39 +00001291 if (D) {
Mike Stumpf5408fe2009-05-16 07:57:57 +00001292 // FIXME: This code is overly simple and should be merged with other global
1293 // handling.
Richard Smitha9b21d22012-02-17 06:48:11 +00001294 GV->setConstant(isTypeConstant(D->getType(), false));
Chris Lattner99b53612009-03-21 08:03:33 +00001295
John McCall110e8e52010-10-29 22:22:43 +00001296 // Set linkage and visibility in case we never see a definition.
John McCallaf146032010-10-30 11:50:40 +00001297 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility();
1298 if (LV.linkage() != ExternalLinkage) {
John McCall15e310a2011-02-19 02:53:41 +00001299 // Don't set internal linkage on declarations.
John McCall110e8e52010-10-29 22:22:43 +00001300 } else {
1301 if (D->hasAttr<DLLImportAttr>())
1302 GV->setLinkage(llvm::GlobalValue::DLLImportLinkage);
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001303 else if (D->hasAttr<WeakAttr>() || D->isWeakImported())
John McCall110e8e52010-10-29 22:22:43 +00001304 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Chris Lattner99b53612009-03-21 08:03:33 +00001305
John McCallaf146032010-10-30 11:50:40 +00001306 // Set visibility on a declaration only if it's explicit.
1307 if (LV.visibilityExplicit())
1308 GV->setVisibility(GetLLVMVisibility(LV.visibility()));
John McCall110e8e52010-10-29 22:22:43 +00001309 }
Eli Friedman56ebe502009-04-19 21:05:03 +00001310
Hans Wennborgde981f32012-06-28 08:01:44 +00001311 if (D->isThreadSpecified())
1312 setTLSMode(GV, *D);
Chris Lattner74391b42009-03-22 21:03:39 +00001313 }
Mike Stump1eb44332009-09-09 15:08:12 +00001314
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00001315 if (AddrSpace != Ty->getAddressSpace())
1316 return llvm::ConstantExpr::getBitCast(GV, Ty);
1317 else
1318 return GV;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001319}
1320
Chris Lattner74391b42009-03-22 21:03:39 +00001321
Anders Carlsson3bd62022011-01-29 18:20:20 +00001322llvm::GlobalVariable *
Chris Lattner5f9e2722011-07-23 10:55:15 +00001323CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001324 llvm::Type *Ty,
Anders Carlsson3bd62022011-01-29 18:20:20 +00001325 llvm::GlobalValue::LinkageTypes Linkage) {
1326 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
1327 llvm::GlobalVariable *OldGV = 0;
1328
1329
1330 if (GV) {
1331 // Check if the variable has the right type.
1332 if (GV->getType()->getElementType() == Ty)
1333 return GV;
1334
1335 // Because C++ name mangling, the only way we can end up with an already
1336 // existing global with the same name is if it has been declared extern "C".
Nico Weberc5f80462012-10-11 10:13:44 +00001337 assert(GV->isDeclaration() && "Declaration has wrong type!");
Anders Carlsson3bd62022011-01-29 18:20:20 +00001338 OldGV = GV;
1339 }
1340
1341 // Create a new variable.
1342 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
1343 Linkage, 0, Name);
1344
1345 if (OldGV) {
1346 // Replace occurrences of the old variable if needed.
1347 GV->takeName(OldGV);
1348
1349 if (!OldGV->use_empty()) {
1350 llvm::Constant *NewPtrForOldDecl =
1351 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
1352 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
1353 }
1354
1355 OldGV->eraseFromParent();
1356 }
1357
1358 return GV;
1359}
1360
Chris Lattner74391b42009-03-22 21:03:39 +00001361/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
1362/// given global variable. If Ty is non-null and if the global doesn't exist,
Eric Christopher0ff258b2012-04-16 23:55:04 +00001363/// then it will be created with the specified type instead of whatever the
Chris Lattner74391b42009-03-22 21:03:39 +00001364/// normal requested type would be.
1365llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001366 llvm::Type *Ty) {
Chris Lattner74391b42009-03-22 21:03:39 +00001367 assert(D->hasGlobalStorage() && "Not a global variable");
1368 QualType ASTTy = D->getType();
1369 if (Ty == 0)
1370 Ty = getTypes().ConvertTypeForMem(ASTTy);
Mike Stump1eb44332009-09-09 15:08:12 +00001371
Chris Lattner2acc6e32011-07-18 04:24:23 +00001372 llvm::PointerType *PTy =
Peter Collingbourne207f4d82011-03-18 22:38:29 +00001373 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
John McCallf746aa62010-03-19 23:29:14 +00001374
Chris Lattner5f9e2722011-07-23 10:55:15 +00001375 StringRef MangledName = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +00001376 return GetOrCreateLLVMGlobal(MangledName, PTy, D);
Chris Lattner74391b42009-03-22 21:03:39 +00001377}
1378
1379/// CreateRuntimeVariable - Create a new runtime global variable with the
1380/// specified type and name.
1381llvm::Constant *
Chris Lattner2acc6e32011-07-18 04:24:23 +00001382CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001383 StringRef Name) {
John McCall1de4d4e2011-04-07 08:22:57 +00001384 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0,
Rafael Espindolac532b502011-01-18 21:07:57 +00001385 true);
Chris Lattner74391b42009-03-22 21:03:39 +00001386}
1387
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001388void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1389 assert(!D->getInit() && "Cannot emit definite definitions here!");
1390
Douglas Gregor7520bd12009-04-21 19:28:58 +00001391 if (MayDeferGeneration(D)) {
1392 // If we have not seen a reference to this variable yet, place it
1393 // into the deferred declarations table to be emitted if needed
1394 // later.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001395 StringRef MangledName = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +00001396 if (!GetGlobalValue(MangledName)) {
Anders Carlsson555b4bb2009-09-10 23:43:36 +00001397 DeferredDecls[MangledName] = D;
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001398 return;
Douglas Gregor7520bd12009-04-21 19:28:58 +00001399 }
1400 }
1401
1402 // The tentative definition is the only definition.
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001403 EmitGlobalVarDefinition(D);
1404}
1405
Douglas Gregor6fb745b2010-05-13 16:44:06 +00001406void CodeGenModule::EmitVTable(CXXRecordDecl *Class, bool DefinitionRequired) {
1407 if (DefinitionRequired)
Charles Davis9ee494f2012-06-23 23:44:00 +00001408 getCXXABI().EmitVTables(Class);
Douglas Gregor6fb745b2010-05-13 16:44:06 +00001409}
1410
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001411llvm::GlobalVariable::LinkageTypes
Anders Carlsson046c2942010-04-17 20:15:18 +00001412CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
Eli Friedmancb5d2d02011-06-10 21:53:06 +00001413 if (RD->getLinkage() != ExternalLinkage)
Douglas Gregordffb8012010-01-06 22:00:56 +00001414 return llvm::GlobalVariable::InternalLinkage;
1415
1416 if (const CXXMethodDecl *KeyFunction
1417 = RD->getASTContext().getKeyFunction(RD)) {
1418 // If this class has a key function, use that to determine the linkage of
1419 // the vtable.
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001420 const FunctionDecl *Def = 0;
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +00001421 if (KeyFunction->hasBody(Def))
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001422 KeyFunction = cast<CXXMethodDecl>(Def);
Douglas Gregordffb8012010-01-06 22:00:56 +00001423
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001424 switch (KeyFunction->getTemplateSpecializationKind()) {
1425 case TSK_Undeclared:
1426 case TSK_ExplicitSpecialization:
Anders Carlsson6d7f8472011-01-30 20:45:54 +00001427 // When compiling with optimizations turned on, we emit all vtables,
1428 // even if the key function is not defined in the current translation
1429 // unit. If this is the case, use available_externally linkage.
1430 if (!Def && CodeGenOpts.OptimizationLevel)
1431 return llvm::GlobalVariable::AvailableExternallyLinkage;
1432
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001433 if (KeyFunction->isInlined())
David Blaikie4e4d0842012-03-11 07:00:24 +00001434 return !Context.getLangOpts().AppleKext ?
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001435 llvm::GlobalVariable::LinkOnceODRLinkage :
1436 llvm::Function::InternalLinkage;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001437
1438 return llvm::GlobalVariable::ExternalLinkage;
1439
1440 case TSK_ImplicitInstantiation:
David Blaikie4e4d0842012-03-11 07:00:24 +00001441 return !Context.getLangOpts().AppleKext ?
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001442 llvm::GlobalVariable::LinkOnceODRLinkage :
1443 llvm::Function::InternalLinkage;
Anders Carlssonf502d932011-01-24 00:46:19 +00001444
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001445 case TSK_ExplicitInstantiationDefinition:
David Blaikie4e4d0842012-03-11 07:00:24 +00001446 return !Context.getLangOpts().AppleKext ?
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001447 llvm::GlobalVariable::WeakODRLinkage :
1448 llvm::Function::InternalLinkage;
Anders Carlssonf502d932011-01-24 00:46:19 +00001449
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001450 case TSK_ExplicitInstantiationDeclaration:
1451 // FIXME: Use available_externally linkage. However, this currently
1452 // breaks LLVM's build due to undefined symbols.
1453 // return llvm::GlobalVariable::AvailableExternallyLinkage;
David Blaikie4e4d0842012-03-11 07:00:24 +00001454 return !Context.getLangOpts().AppleKext ?
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001455 llvm::GlobalVariable::LinkOnceODRLinkage :
1456 llvm::Function::InternalLinkage;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001457 }
Douglas Gregordffb8012010-01-06 22:00:56 +00001458 }
1459
David Blaikie4e4d0842012-03-11 07:00:24 +00001460 if (Context.getLangOpts().AppleKext)
Fariborz Jahanian53bad4e2011-02-04 00:32:39 +00001461 return llvm::Function::InternalLinkage;
1462
Douglas Gregordffb8012010-01-06 22:00:56 +00001463 switch (RD->getTemplateSpecializationKind()) {
1464 case TSK_Undeclared:
1465 case TSK_ExplicitSpecialization:
1466 case TSK_ImplicitInstantiation:
Douglas Gregordffb8012010-01-06 22:00:56 +00001467 // FIXME: Use available_externally linkage. However, this currently
1468 // breaks LLVM's build due to undefined symbols.
1469 // return llvm::GlobalVariable::AvailableExternallyLinkage;
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001470 case TSK_ExplicitInstantiationDeclaration:
Fariborz Jahanian53bad4e2011-02-04 00:32:39 +00001471 return llvm::GlobalVariable::LinkOnceODRLinkage;
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001472
1473 case TSK_ExplicitInstantiationDefinition:
Fariborz Jahanian53bad4e2011-02-04 00:32:39 +00001474 return llvm::GlobalVariable::WeakODRLinkage;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001475 }
David Blaikie30263482012-01-20 21:50:17 +00001476
1477 llvm_unreachable("Invalid TemplateSpecializationKind!");
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001478}
1479
Chris Lattner2acc6e32011-07-18 04:24:23 +00001480CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
Ken Dyck06f486e2011-01-18 02:01:14 +00001481 return Context.toCharUnitsFromBits(
Micah Villmow25a6a842012-10-08 16:25:52 +00001482 TheDataLayout.getTypeStoreSizeInBits(Ty));
Ken Dyck687cc4a2010-01-26 13:48:07 +00001483}
1484
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001485llvm::Constant *
1486CodeGenModule::MaybeEmitGlobalStdInitializerListInitializer(const VarDecl *D,
1487 const Expr *rawInit) {
1488 ArrayRef<ExprWithCleanups::CleanupObject> cleanups;
1489 if (const ExprWithCleanups *withCleanups =
1490 dyn_cast<ExprWithCleanups>(rawInit)) {
1491 cleanups = withCleanups->getObjects();
1492 rawInit = withCleanups->getSubExpr();
1493 }
1494
1495 const InitListExpr *init = dyn_cast<InitListExpr>(rawInit);
1496 if (!init || !init->initializesStdInitializerList() ||
1497 init->getNumInits() == 0)
1498 return 0;
1499
1500 ASTContext &ctx = getContext();
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001501 unsigned numInits = init->getNumInits();
Sebastian Redl062a82c2012-02-27 23:20:01 +00001502 // FIXME: This check is here because we would otherwise silently miscompile
1503 // nested global std::initializer_lists. Better would be to have a real
1504 // implementation.
1505 for (unsigned i = 0; i < numInits; ++i) {
1506 const InitListExpr *inner = dyn_cast<InitListExpr>(init->getInit(i));
1507 if (inner && inner->initializesStdInitializerList()) {
1508 ErrorUnsupported(inner, "nested global std::initializer_list");
1509 return 0;
1510 }
1511 }
1512
1513 // Synthesize a fake VarDecl for the array and initialize that.
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001514 QualType elementType = init->getInit(0)->getType();
1515 llvm::APInt numElements(ctx.getTypeSize(ctx.getSizeType()), numInits);
1516 QualType arrayType = ctx.getConstantArrayType(elementType, numElements,
1517 ArrayType::Normal, 0);
1518
1519 IdentifierInfo *name = &ctx.Idents.get(D->getNameAsString() + "__initlist");
1520 TypeSourceInfo *sourceInfo = ctx.getTrivialTypeSourceInfo(
1521 arrayType, D->getLocation());
1522 VarDecl *backingArray = VarDecl::Create(ctx, const_cast<DeclContext*>(
1523 D->getDeclContext()),
1524 D->getLocStart(), D->getLocation(),
1525 name, arrayType, sourceInfo,
1526 SC_Static, SC_Static);
1527
1528 // Now clone the InitListExpr to initialize the array instead.
1529 // Incredible hack: we want to use the existing InitListExpr here, so we need
1530 // to tell it that it no longer initializes a std::initializer_list.
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00001531 ArrayRef<Expr*> Inits(const_cast<InitListExpr*>(init)->getInits(),
1532 init->getNumInits());
1533 Expr *arrayInit = new (ctx) InitListExpr(ctx, init->getLBraceLoc(), Inits,
1534 init->getRBraceLoc());
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001535 arrayInit->setType(arrayType);
1536
1537 if (!cleanups.empty())
1538 arrayInit = ExprWithCleanups::Create(ctx, arrayInit, cleanups);
1539
1540 backingArray->setInit(arrayInit);
1541
1542 // Emit the definition of the array.
1543 EmitGlobalVarDefinition(backingArray);
1544
1545 // Inspect the initializer list to validate it and determine its type.
1546 // FIXME: doing this every time is probably inefficient; caching would be nice
1547 RecordDecl *record = init->getType()->castAs<RecordType>()->getDecl();
1548 RecordDecl::field_iterator field = record->field_begin();
1549 if (field == record->field_end()) {
1550 ErrorUnsupported(D, "weird std::initializer_list");
1551 return 0;
1552 }
1553 QualType elementPtr = ctx.getPointerType(elementType.withConst());
1554 // Start pointer.
1555 if (!ctx.hasSameType(field->getType(), elementPtr)) {
1556 ErrorUnsupported(D, "weird std::initializer_list");
1557 return 0;
1558 }
1559 ++field;
1560 if (field == record->field_end()) {
1561 ErrorUnsupported(D, "weird std::initializer_list");
1562 return 0;
1563 }
1564 bool isStartEnd = false;
1565 if (ctx.hasSameType(field->getType(), elementPtr)) {
1566 // End pointer.
1567 isStartEnd = true;
1568 } else if(!ctx.hasSameType(field->getType(), ctx.getSizeType())) {
1569 ErrorUnsupported(D, "weird std::initializer_list");
1570 return 0;
1571 }
1572
1573 // Now build an APValue representing the std::initializer_list.
1574 APValue initListValue(APValue::UninitStruct(), 0, 2);
1575 APValue &startField = initListValue.getStructField(0);
1576 APValue::LValuePathEntry startOffsetPathEntry;
1577 startOffsetPathEntry.ArrayIndex = 0;
1578 startField = APValue(APValue::LValueBase(backingArray),
1579 CharUnits::fromQuantity(0),
1580 llvm::makeArrayRef(startOffsetPathEntry),
1581 /*IsOnePastTheEnd=*/false, 0);
1582
1583 if (isStartEnd) {
1584 APValue &endField = initListValue.getStructField(1);
1585 APValue::LValuePathEntry endOffsetPathEntry;
1586 endOffsetPathEntry.ArrayIndex = numInits;
1587 endField = APValue(APValue::LValueBase(backingArray),
1588 ctx.getTypeSizeInChars(elementType) * numInits,
1589 llvm::makeArrayRef(endOffsetPathEntry),
1590 /*IsOnePastTheEnd=*/true, 0);
1591 } else {
1592 APValue &sizeField = initListValue.getStructField(1);
1593 sizeField = APValue(llvm::APSInt(numElements));
1594 }
1595
1596 // Emit the constant for the initializer_list.
Richard Smitha3ca41f2012-03-02 23:27:11 +00001597 llvm::Constant *llvmInit =
1598 EmitConstantValueForMemory(initListValue, D->getType());
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001599 assert(llvmInit && "failed to initialize as constant");
1600 return llvmInit;
1601}
1602
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00001603unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D,
1604 unsigned AddrSpace) {
1605 if (LangOpts.CUDA && CodeGenOpts.CUDAIsDevice) {
1606 if (D->hasAttr<CUDAConstantAttr>())
1607 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant);
1608 else if (D->hasAttr<CUDASharedAttr>())
1609 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared);
1610 else
1611 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device);
1612 }
1613
1614 return AddrSpace;
1615}
1616
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001617void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
Chris Lattner8f32f712007-07-14 00:23:28 +00001618 llvm::Constant *Init = 0;
Eli Friedman77ba7082008-05-30 19:50:47 +00001619 QualType ASTTy = D->getType();
Richard Smith7ca48502012-02-13 22:16:19 +00001620 CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1621 bool NeedsGlobalCtor = false;
1622 bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
Mike Stump1eb44332009-09-09 15:08:12 +00001623
Richard Smith2d6a5672012-01-14 04:30:29 +00001624 const VarDecl *InitDecl;
1625 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001626
Anders Carlsson3bb92692010-01-26 17:43:42 +00001627 if (!InitExpr) {
Eli Friedmancd5f4aa2008-05-30 20:39:54 +00001628 // This is a tentative definition; tentative definitions are
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001629 // implicitly initialized with { 0 }.
1630 //
1631 // Note that tentative definitions are only emitted at the end of
1632 // a translation unit, so they should never have incomplete
1633 // type. In addition, EmitTentativeDefinition makes sure that we
1634 // never attempt to emit a tentative definition if a real one
1635 // exists. A use may still exists, however, so we still may need
1636 // to do a RAUW.
1637 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
Anders Carlssonb0d0ea02009-08-02 21:18:22 +00001638 Init = EmitNullConstant(D->getType());
Eli Friedman77ba7082008-05-30 19:50:47 +00001639 } else {
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001640 // If this is a std::initializer_list, emit the special initializer.
1641 Init = MaybeEmitGlobalStdInitializerListInitializer(D, InitExpr);
1642 // An empty init list will perform zero-initialization, which happens
1643 // to be exactly what we want.
1644 // FIXME: It does so in a global constructor, which is *not* what we
1645 // want.
1646
Fariborz Jahanian4904bf42012-06-26 16:06:38 +00001647 if (!Init) {
1648 initializedGlobalDecl = GlobalDecl(D);
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001649 Init = EmitConstantInit(*InitDecl);
Fariborz Jahanian4904bf42012-06-26 16:06:38 +00001650 }
Eli Friedman6e656f42009-02-20 01:18:21 +00001651 if (!Init) {
Anders Carlsson3bb92692010-01-26 17:43:42 +00001652 QualType T = InitExpr->getType();
Douglas Gregorc446d182010-05-05 20:15:55 +00001653 if (D->getType()->isReferenceType())
1654 T = D->getType();
Richard Smith2d6a5672012-01-14 04:30:29 +00001655
David Blaikie4e4d0842012-03-11 07:00:24 +00001656 if (getLangOpts().CPlusPlus) {
Anders Carlsson89ed31d2009-08-08 23:24:23 +00001657 Init = EmitNullConstant(T);
Richard Smith7ca48502012-02-13 22:16:19 +00001658 NeedsGlobalCtor = true;
Anders Carlsson89ed31d2009-08-08 23:24:23 +00001659 } else {
1660 ErrorUnsupported(D, "static initializer");
1661 Init = llvm::UndefValue::get(getTypes().ConvertType(T));
1662 }
John McCallbf40cb52010-07-15 23:40:35 +00001663 } else {
1664 // We don't need an initializer, so remove the entry for the delayed
Richard Smith7ca48502012-02-13 22:16:19 +00001665 // initializer position (just in case this entry was delayed) if we
1666 // also don't need to register a destructor.
David Blaikie4e4d0842012-03-11 07:00:24 +00001667 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
John McCallbf40cb52010-07-15 23:40:35 +00001668 DelayedCXXInitPosition.erase(D);
Eli Friedman6e656f42009-02-20 01:18:21 +00001669 }
Eli Friedman77ba7082008-05-30 19:50:47 +00001670 }
Eli Friedman77ba7082008-05-30 19:50:47 +00001671
Chris Lattner2acc6e32011-07-18 04:24:23 +00001672 llvm::Type* InitType = Init->getType();
Chris Lattner570585c2009-03-21 09:16:30 +00001673 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
Mike Stump1eb44332009-09-09 15:08:12 +00001674
Chris Lattner570585c2009-03-21 09:16:30 +00001675 // Strip off a bitcast if we got one back.
1676 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
Chris Lattner9d4a15f2009-07-16 16:48:25 +00001677 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
1678 // all zero index gep.
1679 CE->getOpcode() == llvm::Instruction::GetElementPtr);
Chris Lattner570585c2009-03-21 09:16:30 +00001680 Entry = CE->getOperand(0);
1681 }
Mike Stump1eb44332009-09-09 15:08:12 +00001682
Chris Lattner570585c2009-03-21 09:16:30 +00001683 // Entry is now either a Function or GlobalVariable.
1684 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00001685
Chris Lattner570585c2009-03-21 09:16:30 +00001686 // We have a definition after a declaration with the wrong type.
1687 // We must make a new GlobalVariable* and update everything that used OldGV
1688 // (a declaration or tentative definition) with the new GlobalVariable*
1689 // (which will be a definition).
1690 //
1691 // This happens if there is a prototype for a global (e.g.
1692 // "extern int x[];") and then a definition of a different type (e.g.
1693 // "int x[10];"). This also happens when an initializer has a different type
1694 // from the type of the global (this happens with unions).
Chris Lattner570585c2009-03-21 09:16:30 +00001695 if (GV == 0 ||
1696 GV->getType()->getElementType() != InitType ||
Peter Collingbourne207f4d82011-03-18 22:38:29 +00001697 GV->getType()->getAddressSpace() !=
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00001698 GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) {
Mike Stump1eb44332009-09-09 15:08:12 +00001699
John McCallf746aa62010-03-19 23:29:14 +00001700 // Move the old entry aside so that we'll create a new one.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001701 Entry->setName(StringRef());
Daniel Dunbar232350d2009-02-19 05:36:41 +00001702
Chris Lattner570585c2009-03-21 09:16:30 +00001703 // Make a new global with the correct type, this is now guaranteed to work.
1704 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
Chris Lattner0558e792009-03-21 09:25:43 +00001705
Eli Friedman77ba7082008-05-30 19:50:47 +00001706 // Replace all uses of the old global with the new global
Mike Stump1eb44332009-09-09 15:08:12 +00001707 llvm::Constant *NewPtrForOldDecl =
Owen Anderson3c4972d2009-07-29 18:54:39 +00001708 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
Chris Lattner570585c2009-03-21 09:16:30 +00001709 Entry->replaceAllUsesWith(NewPtrForOldDecl);
Eli Friedman77ba7082008-05-30 19:50:47 +00001710
1711 // Erase the old global, since it is no longer used.
Chris Lattner570585c2009-03-21 09:16:30 +00001712 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
Chris Lattner8f32f712007-07-14 00:23:28 +00001713 }
Devang Patel8e53e722007-10-26 16:31:40 +00001714
Julien Lerouge77f68bb2011-09-09 22:41:49 +00001715 if (D->hasAttr<AnnotateAttr>())
1716 AddGlobalAnnotations(D, GV);
Nate Begeman8bd4afe2008-04-19 04:17:09 +00001717
Chris Lattner88a69ad2007-07-13 05:13:43 +00001718 GV->setInitializer(Init);
Chris Lattnere78b86f2009-08-05 05:20:29 +00001719
1720 // If it is safe to mark the global 'constant', do so now.
Richard Smitha9b21d22012-02-17 06:48:11 +00001721 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
1722 isTypeConstant(D->getType(), true));
Mike Stump1eb44332009-09-09 15:08:12 +00001723
Ken Dyck8b752f12010-01-27 17:10:57 +00001724 GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
Richard Smitha9b21d22012-02-17 06:48:11 +00001725
Chris Lattner88a69ad2007-07-13 05:13:43 +00001726 // Set the llvm linkage type as appropriate.
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001727 llvm::GlobalValue::LinkageTypes Linkage =
1728 GetLLVMLinkageVarDefinition(D, GV);
1729 GV->setLinkage(Linkage);
1730 if (Linkage == llvm::GlobalVariable::CommonLinkage)
Chris Lattnere78b86f2009-08-05 05:20:29 +00001731 // common vars aren't constant even if declared const.
1732 GV->setConstant(false);
Daniel Dunbar7e714cd2009-04-10 20:26:50 +00001733
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001734 SetCommonAttributes(D, GV);
Daniel Dunbar04d40782009-04-14 06:00:08 +00001735
John McCall3030eb82010-11-06 09:44:32 +00001736 // Emit the initializer function if necessary.
Richard Smith7ca48502012-02-13 22:16:19 +00001737 if (NeedsGlobalCtor || NeedsGlobalDtor)
1738 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
John McCall3030eb82010-11-06 09:44:32 +00001739
Kostya Serebryany05c5ebc2012-08-21 06:53:28 +00001740 // If we are compiling with ASan, add metadata indicating dynamically
1741 // initialized globals.
Richard Smithca1b62a2012-11-05 21:48:12 +00001742 if (LangOpts.SanitizeAddress && NeedsGlobalCtor) {
Kostya Serebryany05c5ebc2012-08-21 06:53:28 +00001743 llvm::Module &M = getModule();
1744
1745 llvm::NamedMDNode *DynamicInitializers =
1746 M.getOrInsertNamedMetadata("llvm.asan.dynamically_initialized_globals");
1747 llvm::Value *GlobalToAdd[] = { GV };
1748 llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalToAdd);
1749 DynamicInitializers->addOperand(ThisGlobal);
1750 }
1751
Sanjiv Gupta686226b2008-06-05 08:59:10 +00001752 // Emit global variable debug information.
Eric Christopher73fb3502011-10-13 21:45:18 +00001753 if (CGDebugInfo *DI = getModuleDebugInfo())
Douglas Gregor4cdad312012-10-23 20:05:01 +00001754 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
Alexey Samsonovfd00eec2012-05-04 07:39:27 +00001755 DI->EmitGlobalVariable(GV, D);
Chris Lattner88a69ad2007-07-13 05:13:43 +00001756}
Reid Spencer5f016e22007-07-11 17:01:13 +00001757
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001758llvm::GlobalValue::LinkageTypes
1759CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D,
1760 llvm::GlobalVariable *GV) {
1761 GVALinkage Linkage = getContext().GetGVALinkageForVariable(D);
1762 if (Linkage == GVA_Internal)
1763 return llvm::Function::InternalLinkage;
1764 else if (D->hasAttr<DLLImportAttr>())
1765 return llvm::Function::DLLImportLinkage;
1766 else if (D->hasAttr<DLLExportAttr>())
1767 return llvm::Function::DLLExportLinkage;
1768 else if (D->hasAttr<WeakAttr>()) {
1769 if (GV->isConstant())
1770 return llvm::GlobalVariable::WeakODRLinkage;
1771 else
1772 return llvm::GlobalVariable::WeakAnyLinkage;
1773 } else if (Linkage == GVA_TemplateInstantiation ||
1774 Linkage == GVA_ExplicitTemplateInstantiation)
John McCall99ace162011-04-12 01:46:54 +00001775 return llvm::GlobalVariable::WeakODRLinkage;
David Blaikie4e4d0842012-03-11 07:00:24 +00001776 else if (!getLangOpts().CPlusPlus &&
Eric Christophera6cf1e72010-12-02 02:45:55 +00001777 ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) ||
1778 D->getAttr<CommonAttr>()) &&
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001779 !D->hasExternalStorage() && !D->getInit() &&
Fariborz Jahanianab27d6e2011-06-20 17:50:03 +00001780 !D->getAttr<SectionAttr>() && !D->isThreadSpecified() &&
1781 !D->getAttr<WeakImportAttr>()) {
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001782 // Thread local vars aren't considered common linkage.
1783 return llvm::GlobalVariable::CommonLinkage;
1784 }
1785 return llvm::GlobalVariable::ExternalLinkage;
1786}
1787
Chris Lattnerbdb01322009-05-05 06:16:31 +00001788/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
1789/// implement a function with no prototype, e.g. "int foo() {}". If there are
1790/// existing call uses of the old function in the module, this adjusts them to
1791/// call the new function directly.
1792///
1793/// This is not just a cleanup: the always_inline pass requires direct calls to
1794/// functions to be able to inline them. If there is a bitcast in the way, it
1795/// won't inline them. Instcombine normally deletes these calls, but it isn't
1796/// run at -O0.
1797static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
1798 llvm::Function *NewFn) {
1799 // If we're redefining a global as a function, don't transform it.
1800 llvm::Function *OldFn = dyn_cast<llvm::Function>(Old);
1801 if (OldFn == 0) return;
Mike Stump1eb44332009-09-09 15:08:12 +00001802
Chris Lattner2acc6e32011-07-18 04:24:23 +00001803 llvm::Type *NewRetTy = NewFn->getReturnType();
Chris Lattner5f9e2722011-07-23 10:55:15 +00001804 SmallVector<llvm::Value*, 4> ArgList;
Chris Lattnerbdb01322009-05-05 06:16:31 +00001805
1806 for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end();
Benjamin Kramerdbf02bc2010-04-10 11:02:40 +00001807 UI != E; ) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00001808 // TODO: Do invokes ever occur in C code? If so, we should handle them too.
Benjamin Kramerdbf02bc2010-04-10 11:02:40 +00001809 llvm::Value::use_iterator I = UI++; // Increment before the CI is erased.
1810 llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*I);
Gabor Greif8670cd32010-07-28 09:19:33 +00001811 if (!CI) continue; // FIXME: when we allow Invoke, just do CallSite CS(*I)
Gabor Greif35db3b92010-04-10 03:45:50 +00001812 llvm::CallSite CS(CI);
Benjamin Kramerdbf02bc2010-04-10 11:02:40 +00001813 if (!CI || !CS.isCallee(I)) continue;
Mike Stump1eb44332009-09-09 15:08:12 +00001814
Chris Lattnerbdb01322009-05-05 06:16:31 +00001815 // If the return types don't match exactly, and if the call isn't dead, then
1816 // we can't transform this call.
1817 if (CI->getType() != NewRetTy && !CI->use_empty())
1818 continue;
1819
John McCall40f9c302011-08-03 00:43:55 +00001820 // Get the attribute list.
1821 llvm::SmallVector<llvm::AttributeWithIndex, 8> AttrVec;
1822 llvm::AttrListPtr AttrList = CI->getAttributes();
1823
1824 // Get any return attributes.
1825 llvm::Attributes RAttrs = AttrList.getRetAttributes();
1826
1827 // Add the return attributes.
Bill Wendling4d68ed52012-10-14 08:54:39 +00001828 if (RAttrs.hasAttributes())
Bill Wendling75d37b42012-10-15 07:31:59 +00001829 AttrVec.push_back(llvm::
1830 AttributeWithIndex::get(llvm::AttrListPtr::ReturnIndex,
1831 RAttrs));
John McCall40f9c302011-08-03 00:43:55 +00001832
Chris Lattnerbdb01322009-05-05 06:16:31 +00001833 // If the function was passed too few arguments, don't transform. If extra
1834 // arguments were passed, we silently drop them. If any of the types
1835 // mismatch, we don't transform.
1836 unsigned ArgNo = 0;
1837 bool DontTransform = false;
1838 for (llvm::Function::arg_iterator AI = NewFn->arg_begin(),
1839 E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) {
Gabor Greif35db3b92010-04-10 03:45:50 +00001840 if (CS.arg_size() == ArgNo ||
1841 CS.getArgument(ArgNo)->getType() != AI->getType()) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00001842 DontTransform = true;
1843 break;
1844 }
John McCall40f9c302011-08-03 00:43:55 +00001845
1846 // Add any parameter attributes.
Bill Wendling4d68ed52012-10-14 08:54:39 +00001847 llvm::Attributes PAttrs = AttrList.getParamAttributes(ArgNo + 1);
1848 if (PAttrs.hasAttributes())
John McCall40f9c302011-08-03 00:43:55 +00001849 AttrVec.push_back(llvm::AttributeWithIndex::get(ArgNo + 1, PAttrs));
Chris Lattnerbdb01322009-05-05 06:16:31 +00001850 }
1851 if (DontTransform)
1852 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00001853
Bill Wendling4d68ed52012-10-14 08:54:39 +00001854 llvm::Attributes FnAttrs = AttrList.getFnAttributes();
1855 if (FnAttrs.hasAttributes())
Bill Wendling75d37b42012-10-15 07:31:59 +00001856 AttrVec.push_back(llvm::
1857 AttributeWithIndex::get(llvm::AttrListPtr::FunctionIndex,
1858 FnAttrs));
John McCall40f9c302011-08-03 00:43:55 +00001859
Chris Lattnerbdb01322009-05-05 06:16:31 +00001860 // Okay, we can transform this. Create the new call instruction and copy
1861 // over the required information.
Gabor Greif6ba728d2010-04-10 02:56:12 +00001862 ArgList.append(CS.arg_begin(), CS.arg_begin() + ArgNo);
Jay Foad4c7d9f12011-07-15 08:37:34 +00001863 llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList, "", CI);
Chris Lattnerbdb01322009-05-05 06:16:31 +00001864 ArgList.clear();
Benjamin Kramerffbb15e2009-10-05 13:47:21 +00001865 if (!NewCall->getType()->isVoidTy())
Chris Lattnerbdb01322009-05-05 06:16:31 +00001866 NewCall->takeName(CI);
Bill Wendlingdd851592012-11-20 05:09:43 +00001867 NewCall->setAttributes(llvm::AttrListPtr::get(OldFn->getContext(), AttrVec));
Daniel Dunbarca6408c2009-09-12 00:59:20 +00001868 NewCall->setCallingConv(CI->getCallingConv());
Chris Lattnerbdb01322009-05-05 06:16:31 +00001869
1870 // Finally, remove the old call, replacing any uses with the new one.
Chris Lattner00549fc2009-10-14 05:49:21 +00001871 if (!CI->use_empty())
1872 CI->replaceAllUsesWith(NewCall);
Devang Patel3b122bc2009-10-13 17:02:04 +00001873
Chris Lattnerc6034632010-04-01 06:31:43 +00001874 // Copy debug location attached to CI.
1875 if (!CI->getDebugLoc().isUnknown())
1876 NewCall->setDebugLoc(CI->getDebugLoc());
Chris Lattnerbdb01322009-05-05 06:16:31 +00001877 CI->eraseFromParent();
1878 }
1879}
1880
Rafael Espindola02503932012-03-08 15:51:03 +00001881void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
1882 TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind();
1883 // If we have a definition, this might be a deferred decl. If the
1884 // instantiation is explicit, make sure we emit it at the end.
1885 if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
1886 GetAddrOfGlobalVar(VD);
Rafael Espindola234fe652012-03-05 10:54:55 +00001887}
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001888
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001889void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001890 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
John McCalld26bc762011-03-09 04:27:21 +00001891
John McCall1f6f9612011-03-09 08:12:35 +00001892 // Compute the function info and LLVM type.
John McCallde5d3c72012-02-17 03:33:10 +00001893 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
1894 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
John McCalld26bc762011-03-09 04:27:21 +00001895
Chris Lattner9fa959d2009-05-12 20:58:15 +00001896 // Get or create the prototype for the function.
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001897 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
Mike Stump1eb44332009-09-09 15:08:12 +00001898
Chris Lattner0558e792009-03-21 09:25:43 +00001899 // Strip off a bitcast if we got one back.
1900 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
1901 assert(CE->getOpcode() == llvm::Instruction::BitCast);
1902 Entry = CE->getOperand(0);
1903 }
Mike Stump1eb44332009-09-09 15:08:12 +00001904
1905
Chris Lattner0558e792009-03-21 09:25:43 +00001906 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00001907 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00001908
Daniel Dunbar42745812009-03-09 23:53:08 +00001909 // If the types mismatch then we have to rewrite the definition.
Chris Lattnerbdb01322009-05-05 06:16:31 +00001910 assert(OldFn->isDeclaration() &&
Chris Lattner0558e792009-03-21 09:25:43 +00001911 "Shouldn't replace non-declaration");
Chris Lattner34809502009-03-21 08:53:37 +00001912
Chris Lattner62b33ea2009-03-21 08:38:50 +00001913 // F is the Function* for the one with the wrong type, we must make a new
1914 // Function* and update everything that used F (a declaration) with the new
1915 // Function* (which will be a definition).
1916 //
1917 // This happens if there is a prototype for a function
1918 // (e.g. "int f()") and then a definition of a different type
John McCallf746aa62010-03-19 23:29:14 +00001919 // (e.g. "int f(int x)"). Move the old function aside so that it
1920 // doesn't interfere with GetAddrOfFunction.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001921 OldFn->setName(StringRef());
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001922 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
Mike Stump1eb44332009-09-09 15:08:12 +00001923
Chris Lattnerbdb01322009-05-05 06:16:31 +00001924 // If this is an implementation of a function without a prototype, try to
1925 // replace any existing uses of the function (which may be calls) with uses
1926 // of the new function
Chris Lattner9fa959d2009-05-12 20:58:15 +00001927 if (D->getType()->isFunctionNoProtoType()) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00001928 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
Chris Lattner9fa959d2009-05-12 20:58:15 +00001929 OldFn->removeDeadConstantUsers();
1930 }
Mike Stump1eb44332009-09-09 15:08:12 +00001931
Chris Lattner62b33ea2009-03-21 08:38:50 +00001932 // Replace uses of F with the Function we will endow with a body.
Chris Lattnerbdb01322009-05-05 06:16:31 +00001933 if (!Entry->use_empty()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001934 llvm::Constant *NewPtrForOldDecl =
Owen Anderson3c4972d2009-07-29 18:54:39 +00001935 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
Chris Lattnerbdb01322009-05-05 06:16:31 +00001936 Entry->replaceAllUsesWith(NewPtrForOldDecl);
1937 }
Mike Stump1eb44332009-09-09 15:08:12 +00001938
Chris Lattner62b33ea2009-03-21 08:38:50 +00001939 // Ok, delete the old function now, which is dead.
Chris Lattnerbdb01322009-05-05 06:16:31 +00001940 OldFn->eraseFromParent();
Mike Stump1eb44332009-09-09 15:08:12 +00001941
Chris Lattner0558e792009-03-21 09:25:43 +00001942 Entry = NewFn;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001943 }
Mike Stump1eb44332009-09-09 15:08:12 +00001944
John McCall112c9672010-11-02 21:04:24 +00001945 // We need to set linkage and visibility on the function before
1946 // generating code for it because various parts of IR generation
1947 // want to propagate this information down (e.g. to local static
1948 // declarations).
Chris Lattner0558e792009-03-21 09:25:43 +00001949 llvm::Function *Fn = cast<llvm::Function>(Entry);
John McCall8b242332010-05-25 04:30:21 +00001950 setFunctionLinkage(D, Fn);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001951
John McCall112c9672010-11-02 21:04:24 +00001952 // FIXME: this is redundant with part of SetFunctionDefinitionAttributes
Anders Carlsson0ffeaad2011-01-29 19:39:23 +00001953 setGlobalVisibility(Fn, D);
John McCall112c9672010-11-02 21:04:24 +00001954
John McCalld26bc762011-03-09 04:27:21 +00001955 CodeGenFunction(*this).GenerateCode(D, Fn, FI);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +00001956
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001957 SetFunctionDefinitionAttributes(D, Fn);
1958 SetLLVMFunctionAttributesForDefinition(D, Fn);
Mike Stump1eb44332009-09-09 15:08:12 +00001959
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001960 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
Daniel Dunbar219df662008-09-08 23:44:31 +00001961 AddGlobalCtor(Fn, CA->getPriority());
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001962 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
Daniel Dunbar219df662008-09-08 23:44:31 +00001963 AddGlobalDtor(Fn, DA->getPriority());
Julien Lerouge77f68bb2011-09-09 22:41:49 +00001964 if (D->hasAttr<AnnotateAttr>())
1965 AddGlobalAnnotations(D, Fn);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001966}
1967
John McCallf746aa62010-03-19 23:29:14 +00001968void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
1969 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001970 const AliasAttr *AA = D->getAttr<AliasAttr>();
Chris Lattnerbd532712009-03-22 21:47:11 +00001971 assert(AA && "Not an alias?");
1972
Chris Lattner5f9e2722011-07-23 10:55:15 +00001973 StringRef MangledName = getMangledName(GD);
Mike Stump1eb44332009-09-09 15:08:12 +00001974
John McCallf746aa62010-03-19 23:29:14 +00001975 // If there is a definition in the module, then it wins over the alias.
1976 // This is dubious, but allow it to be safe. Just ignore the alias.
1977 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1978 if (Entry && !Entry->isDeclaration())
1979 return;
1980
Chris Lattner2acc6e32011-07-18 04:24:23 +00001981 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
Chris Lattnerbd532712009-03-22 21:47:11 +00001982
1983 // Create a reference to the named value. This ensures that it is emitted
1984 // if a deferred decl.
1985 llvm::Constant *Aliasee;
1986 if (isa<llvm::FunctionType>(DeclTy))
Alex Rosenbergc857ce82012-10-05 23:12:53 +00001987 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001988 /*ForVTable=*/false);
Chris Lattnerbd532712009-03-22 21:47:11 +00001989 else
John McCallf746aa62010-03-19 23:29:14 +00001990 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Owen Anderson96e0fc72009-07-29 22:16:19 +00001991 llvm::PointerType::getUnqual(DeclTy), 0);
Chris Lattnerbd532712009-03-22 21:47:11 +00001992
1993 // Create the new alias itself, but don't set a name yet.
Mike Stump1eb44332009-09-09 15:08:12 +00001994 llvm::GlobalValue *GA =
Chris Lattnerbd532712009-03-22 21:47:11 +00001995 new llvm::GlobalAlias(Aliasee->getType(),
1996 llvm::Function::ExternalLinkage,
1997 "", Aliasee, &getModule());
Mike Stump1eb44332009-09-09 15:08:12 +00001998
Chris Lattnerbd532712009-03-22 21:47:11 +00001999 if (Entry) {
John McCallf746aa62010-03-19 23:29:14 +00002000 assert(Entry->isDeclaration());
2001
Chris Lattnerbd532712009-03-22 21:47:11 +00002002 // If there is a declaration in the module, then we had an extern followed
2003 // by the alias, as in:
2004 // extern int test6();
2005 // ...
2006 // int test6() __attribute__((alias("test7")));
2007 //
2008 // Remove it and replace uses of it with the alias.
John McCallf746aa62010-03-19 23:29:14 +00002009 GA->takeName(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00002010
Owen Anderson3c4972d2009-07-29 18:54:39 +00002011 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
Chris Lattnerbd532712009-03-22 21:47:11 +00002012 Entry->getType()));
Chris Lattnerbd532712009-03-22 21:47:11 +00002013 Entry->eraseFromParent();
John McCallf746aa62010-03-19 23:29:14 +00002014 } else {
Anders Carlsson9a20d552010-06-22 16:16:50 +00002015 GA->setName(MangledName);
Chris Lattnerbd532712009-03-22 21:47:11 +00002016 }
Mike Stump1eb44332009-09-09 15:08:12 +00002017
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002018 // Set attributes which are particular to an alias; this is a
2019 // specialization of the attributes which may be set on a global
2020 // variable/function.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002021 if (D->hasAttr<DLLExportAttr>()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002022 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2023 // The dllexport attribute is ignored for undefined symbols.
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +00002024 if (FD->hasBody())
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002025 GA->setLinkage(llvm::Function::DLLExportLinkage);
2026 } else {
2027 GA->setLinkage(llvm::Function::DLLExportLinkage);
2028 }
Mike Stump1eb44332009-09-09 15:08:12 +00002029 } else if (D->hasAttr<WeakAttr>() ||
Rafael Espindola11e8ce72010-02-23 22:00:30 +00002030 D->hasAttr<WeakRefAttr>() ||
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002031 D->isWeakImported()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002032 GA->setLinkage(llvm::Function::WeakAnyLinkage);
2033 }
2034
2035 SetCommonAttributes(D, GA);
Chris Lattnerbd532712009-03-22 21:47:11 +00002036}
2037
Benjamin Kramer8dd55a32011-07-14 17:45:50 +00002038llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
Chris Lattner2d3ba4f2011-07-23 17:14:25 +00002039 ArrayRef<llvm::Type*> Tys) {
Jay Foaddf983a82011-07-12 14:06:48 +00002040 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
Benjamin Kramer8dd55a32011-07-14 17:45:50 +00002041 Tys);
Chris Lattner7acda7c2007-12-18 00:25:38 +00002042}
Chris Lattnerbef20ac2007-08-31 04:31:45 +00002043
Daniel Dunbar1d552912009-07-23 22:52:48 +00002044static llvm::StringMapEntry<llvm::Constant*> &
2045GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
2046 const StringLiteral *Literal,
Daniel Dunbar70ee9752009-07-23 23:41:22 +00002047 bool TargetIsLSB,
Daniel Dunbar1d552912009-07-23 22:52:48 +00002048 bool &IsUTF16,
2049 unsigned &StringLength) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00002050 StringRef String = Literal->getString();
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00002051 unsigned NumBytes = String.size();
Daniel Dunbar1d552912009-07-23 22:52:48 +00002052
Daniel Dunbarf015b032009-09-22 10:03:52 +00002053 // Check for simple case.
2054 if (!Literal->containsNonAsciiOrNull()) {
2055 StringLength = NumBytes;
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00002056 return Map.GetOrCreateValue(String);
Daniel Dunbarf015b032009-09-22 10:03:52 +00002057 }
2058
Bill Wendling84392d02012-03-30 00:26:17 +00002059 // Otherwise, convert the UTF8 literals into a string of shorts.
2060 IsUTF16 = true;
2061
2062 SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
Roman Divacky31ba6132012-09-06 15:59:27 +00002063 const UTF8 *FromPtr = (const UTF8 *)String.data();
Daniel Dunbar1d552912009-07-23 22:52:48 +00002064 UTF16 *ToPtr = &ToBuf[0];
Mike Stump1eb44332009-09-09 15:08:12 +00002065
Fariborz Jahaniane7ddfb92010-09-07 19:57:04 +00002066 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
2067 &ToPtr, ToPtr + NumBytes,
2068 strictConversion);
Mike Stump1eb44332009-09-09 15:08:12 +00002069
Daniel Dunbar70ee9752009-07-23 23:41:22 +00002070 // ConvertUTF8toUTF16 returns the length in ToPtr.
Daniel Dunbar1d552912009-07-23 22:52:48 +00002071 StringLength = ToPtr - &ToBuf[0];
Daniel Dunbar70ee9752009-07-23 23:41:22 +00002072
Bill Wendling84392d02012-03-30 00:26:17 +00002073 // Add an explicit null.
2074 *ToPtr = 0;
2075 return Map.
2076 GetOrCreateValue(StringRef(reinterpret_cast<const char *>(ToBuf.data()),
2077 (StringLength + 1) * 2));
Daniel Dunbar1d552912009-07-23 22:52:48 +00002078}
2079
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002080static llvm::StringMapEntry<llvm::Constant*> &
2081GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map,
Bill Wendling8322c232012-03-29 22:12:09 +00002082 const StringLiteral *Literal,
2083 unsigned &StringLength) {
2084 StringRef String = Literal->getString();
2085 StringLength = String.size();
2086 return Map.GetOrCreateValue(String);
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002087}
2088
Daniel Dunbar1d552912009-07-23 22:52:48 +00002089llvm::Constant *
2090CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
2091 unsigned StringLength = 0;
2092 bool isUTF16 = false;
2093 llvm::StringMapEntry<llvm::Constant*> &Entry =
Mike Stump1eb44332009-09-09 15:08:12 +00002094 GetConstantCFStringEntry(CFConstantStringMap, Literal,
Micah Villmow25a6a842012-10-08 16:25:52 +00002095 getDataLayout().isLittleEndian(),
Daniel Dunbar70ee9752009-07-23 23:41:22 +00002096 isUTF16, StringLength);
Mike Stump1eb44332009-09-09 15:08:12 +00002097
Daniel Dunbar1d552912009-07-23 22:52:48 +00002098 if (llvm::Constant *C = Entry.getValue())
2099 return C;
Mike Stump1eb44332009-09-09 15:08:12 +00002100
Chris Lattner8b418682012-02-07 00:39:47 +00002101 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
Daniel Dunbar3e9df992008-08-23 18:37:06 +00002102 llvm::Constant *Zeros[] = { Zero, Zero };
Mike Stump1eb44332009-09-09 15:08:12 +00002103
Chris Lattner9d4a15f2009-07-16 16:48:25 +00002104 // If we don't already have it, get __CFConstantStringClassReference.
Anders Carlssonc9e20912007-08-21 00:21:21 +00002105 if (!CFConstantStringClassRef) {
Chris Lattner2acc6e32011-07-18 04:24:23 +00002106 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00002107 Ty = llvm::ArrayType::get(Ty, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00002108 llvm::Constant *GV = CreateRuntimeVariable(Ty,
Chris Lattner9d4a15f2009-07-16 16:48:25 +00002109 "__CFConstantStringClassReference");
Daniel Dunbar3e9df992008-08-23 18:37:06 +00002110 // Decay array -> ptr
2111 CFConstantStringClassRef =
Jay Foada5c04342011-07-21 14:31:17 +00002112 llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Anders Carlssonc9e20912007-08-21 00:21:21 +00002113 }
Mike Stump1eb44332009-09-09 15:08:12 +00002114
Anders Carlssone3daa762008-11-15 18:54:24 +00002115 QualType CFTy = getContext().getCFConstantStringType();
Daniel Dunbar3e9df992008-08-23 18:37:06 +00002116
Chris Lattner2acc6e32011-07-18 04:24:23 +00002117 llvm::StructType *STy =
Anders Carlssone3daa762008-11-15 18:54:24 +00002118 cast<llvm::StructType>(getTypes().ConvertType(CFTy));
2119
Benjamin Kramer1d236ab2011-10-15 12:20:02 +00002120 llvm::Constant *Fields[4];
Douglas Gregor44b43212008-12-11 16:49:14 +00002121
Anders Carlssonc9e20912007-08-21 00:21:21 +00002122 // Class pointer.
Anders Carlsson5add6832009-08-16 05:55:31 +00002123 Fields[0] = CFConstantStringClassRef;
Mike Stump1eb44332009-09-09 15:08:12 +00002124
Anders Carlssonc9e20912007-08-21 00:21:21 +00002125 // Flags.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002126 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
Mike Stump1eb44332009-09-09 15:08:12 +00002127 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
Anders Carlsson5add6832009-08-16 05:55:31 +00002128 llvm::ConstantInt::get(Ty, 0x07C8);
2129
Anders Carlssonc9e20912007-08-21 00:21:21 +00002130 // String pointer.
Bill Wendling84392d02012-03-30 00:26:17 +00002131 llvm::Constant *C = 0;
2132 if (isUTF16) {
2133 ArrayRef<uint16_t> Arr =
2134 llvm::makeArrayRef<uint16_t>((uint16_t*)Entry.getKey().data(),
2135 Entry.getKey().size() / 2);
2136 C = llvm::ConstantDataArray::get(VMContext, Arr);
2137 } else {
2138 C = llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
2139 }
Daniel Dunbara9668e02009-04-03 00:57:44 +00002140
Chris Lattner95b851e2009-07-16 05:03:48 +00002141 llvm::GlobalValue::LinkageTypes Linkage;
Bill Wendling1bf7a3f2012-01-10 08:46:39 +00002142 if (isUTF16)
Chris Lattner278b9f02009-10-14 05:55:45 +00002143 // FIXME: why do utf strings get "_" labels instead of "L" labels?
Chris Lattner95b851e2009-07-16 05:03:48 +00002144 Linkage = llvm::GlobalValue::InternalLinkage;
Bill Wendling1bf7a3f2012-01-10 08:46:39 +00002145 else
Rafael Espindola584acf22011-03-14 17:55:00 +00002146 // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error
2147 // when using private linkage. It is not clear if this is a bug in ld
2148 // or a reasonable new restriction.
Rafael Espindoladc0f1372011-03-14 21:08:19 +00002149 Linkage = llvm::GlobalValue::LinkerPrivateLinkage;
Chris Lattner278b9f02009-10-14 05:55:45 +00002150
Bill Wendling1bf7a3f2012-01-10 08:46:39 +00002151 // Note: -fwritable-strings doesn't make the backing store strings of
2152 // CFStrings writable. (See <rdar://problem/10657500>)
Mike Stump1eb44332009-09-09 15:08:12 +00002153 llvm::GlobalVariable *GV =
Bill Wendling1bf7a3f2012-01-10 08:46:39 +00002154 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
2155 Linkage, C, ".str");
Rafael Espindolab266a1f2011-01-17 16:31:00 +00002156 GV->setUnnamedAddr(true);
Daniel Dunbara9668e02009-04-03 00:57:44 +00002157 if (isUTF16) {
Ken Dyck4da244c2010-01-26 18:46:23 +00002158 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
2159 GV->setAlignment(Align.getQuantity());
Daniel Dunbarf7e903d2011-04-12 23:30:52 +00002160 } else {
2161 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2162 GV->setAlignment(Align.getQuantity());
Daniel Dunbara9668e02009-04-03 00:57:44 +00002163 }
Bill Wendling84392d02012-03-30 00:26:17 +00002164
2165 // String.
Jay Foada5c04342011-07-21 14:31:17 +00002166 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Anders Carlsson5add6832009-08-16 05:55:31 +00002167
Bill Wendling84392d02012-03-30 00:26:17 +00002168 if (isUTF16)
2169 // Cast the UTF16 string to the correct type.
2170 Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy);
2171
Anders Carlssonc9e20912007-08-21 00:21:21 +00002172 // String length.
2173 Ty = getTypes().ConvertType(getContext().LongTy);
Anders Carlsson5add6832009-08-16 05:55:31 +00002174 Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
Mike Stump1eb44332009-09-09 15:08:12 +00002175
Anders Carlssonc9e20912007-08-21 00:21:21 +00002176 // The struct.
Owen Anderson08e25242009-07-27 22:29:56 +00002177 C = llvm::ConstantStruct::get(STy, Fields);
Mike Stump1eb44332009-09-09 15:08:12 +00002178 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2179 llvm::GlobalVariable::PrivateLinkage, C,
Chris Lattner95b851e2009-07-16 05:03:48 +00002180 "_unnamed_cfstring_");
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00002181 if (const char *Sect = getContext().getTargetInfo().getCFStringSection())
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00002182 GV->setSection(Sect);
Daniel Dunbar1d552912009-07-23 22:52:48 +00002183 Entry.setValue(GV);
Mike Stump1eb44332009-09-09 15:08:12 +00002184
Anders Carlsson0c678292007-11-01 00:41:52 +00002185 return GV;
Anders Carlssonc9e20912007-08-21 00:21:21 +00002186}
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002187
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002188static RecordDecl *
2189CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK,
2190 DeclContext *DC, IdentifierInfo *Id) {
2191 SourceLocation Loc;
David Blaikie4e4d0842012-03-11 07:00:24 +00002192 if (Ctx.getLangOpts().CPlusPlus)
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002193 return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2194 else
2195 return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2196}
2197
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00002198llvm::Constant *
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002199CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002200 unsigned StringLength = 0;
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002201 llvm::StringMapEntry<llvm::Constant*> &Entry =
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002202 GetConstantStringEntry(CFConstantStringMap, Literal, StringLength);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002203
2204 if (llvm::Constant *C = Entry.getValue())
2205 return C;
2206
Chris Lattner812234b2012-02-06 22:47:00 +00002207 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002208 llvm::Constant *Zeros[] = { Zero, Zero };
2209
Fariborz Jahanianec951e02010-04-23 22:33:39 +00002210 // If we don't already have it, get _NSConstantStringClassReference.
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002211 if (!ConstantStringClassRef) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002212 std::string StringClass(getLangOpts().ObjCConstantStringClass);
Chris Lattner2acc6e32011-07-18 04:24:23 +00002213 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002214 llvm::Constant *GV;
John McCall260611a2012-06-20 06:18:46 +00002215 if (LangOpts.ObjCRuntime.isNonFragile()) {
Fariborz Jahanian25dba5d2011-05-17 22:46:11 +00002216 std::string str =
2217 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
2218 : "OBJC_CLASS_$_" + StringClass;
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00002219 GV = getObjCRuntime().GetClassGlobal(str);
2220 // Make sure the result is of the correct type.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002221 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00002222 ConstantStringClassRef =
2223 llvm::ConstantExpr::getBitCast(GV, PTy);
2224 } else {
Fariborz Jahanian25dba5d2011-05-17 22:46:11 +00002225 std::string str =
2226 StringClass.empty() ? "_NSConstantStringClassReference"
2227 : "_" + StringClass + "ClassReference";
Chris Lattner2acc6e32011-07-18 04:24:23 +00002228 llvm::Type *PTy = llvm::ArrayType::get(Ty, 0);
Fariborz Jahanian25dba5d2011-05-17 22:46:11 +00002229 GV = CreateRuntimeVariable(PTy, str);
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00002230 // Decay array -> ptr
2231 ConstantStringClassRef =
Jay Foada5c04342011-07-21 14:31:17 +00002232 llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002233 }
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002234 }
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002235
2236 if (!NSConstantStringType) {
2237 // Construct the type for a constant NSString.
2238 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2239 Context.getTranslationUnitDecl(),
2240 &Context.Idents.get("__builtin_NSString"));
2241 D->startDefinition();
2242
2243 QualType FieldTypes[3];
2244
2245 // const int *isa;
2246 FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst());
2247 // const char *str;
2248 FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst());
2249 // unsigned int length;
2250 FieldTypes[2] = Context.UnsignedIntTy;
2251
2252 // Create fields
2253 for (unsigned i = 0; i < 3; ++i) {
2254 FieldDecl *Field = FieldDecl::Create(Context, D,
2255 SourceLocation(),
2256 SourceLocation(), 0,
2257 FieldTypes[i], /*TInfo=*/0,
2258 /*BitWidth=*/0,
2259 /*Mutable=*/false,
Richard Smithca523302012-06-10 03:12:00 +00002260 ICIS_NoInit);
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002261 Field->setAccess(AS_public);
2262 D->addDecl(Field);
2263 }
2264
2265 D->completeDefinition();
2266 QualType NSTy = Context.getTagDeclType(D);
2267 NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy));
2268 }
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002269
Benjamin Kramer1d236ab2011-10-15 12:20:02 +00002270 llvm::Constant *Fields[3];
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002271
2272 // Class pointer.
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002273 Fields[0] = ConstantStringClassRef;
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002274
2275 // String pointer.
Chris Lattner94010692012-02-05 02:30:40 +00002276 llvm::Constant *C =
2277 llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002278
2279 llvm::GlobalValue::LinkageTypes Linkage;
2280 bool isConstant;
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002281 Linkage = llvm::GlobalValue::PrivateLinkage;
David Blaikie4e4d0842012-03-11 07:00:24 +00002282 isConstant = !LangOpts.WritableStrings;
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002283
2284 llvm::GlobalVariable *GV =
2285 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
2286 ".str");
Rafael Espindola803d3072011-01-17 22:11:21 +00002287 GV->setUnnamedAddr(true);
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002288 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2289 GV->setAlignment(Align.getQuantity());
Jay Foada5c04342011-07-21 14:31:17 +00002290 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002291
2292 // String length.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002293 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002294 Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
2295
2296 // The struct.
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002297 C = llvm::ConstantStruct::get(NSConstantStringType, Fields);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002298 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2299 llvm::GlobalVariable::PrivateLinkage, C,
2300 "_unnamed_nsstring_");
2301 // FIXME. Fix section.
Fariborz Jahanianec951e02010-04-23 22:33:39 +00002302 if (const char *Sect =
John McCall260611a2012-06-20 06:18:46 +00002303 LangOpts.ObjCRuntime.isNonFragile()
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00002304 ? getContext().getTargetInfo().getNSStringNonFragileABISection()
2305 : getContext().getTargetInfo().getNSStringSection())
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002306 GV->setSection(Sect);
2307 Entry.setValue(GV);
2308
2309 return GV;
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00002310}
2311
Douglas Gregor0815b572011-08-09 17:23:49 +00002312QualType CodeGenModule::getObjCFastEnumerationStateType() {
2313 if (ObjCFastEnumerationStateType.isNull()) {
2314 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2315 Context.getTranslationUnitDecl(),
2316 &Context.Idents.get("__objcFastEnumerationState"));
2317 D->startDefinition();
2318
2319 QualType FieldTypes[] = {
2320 Context.UnsignedLongTy,
2321 Context.getPointerType(Context.getObjCIdType()),
2322 Context.getPointerType(Context.UnsignedLongTy),
2323 Context.getConstantArrayType(Context.UnsignedLongTy,
2324 llvm::APInt(32, 5), ArrayType::Normal, 0)
2325 };
2326
2327 for (size_t i = 0; i < 4; ++i) {
2328 FieldDecl *Field = FieldDecl::Create(Context,
2329 D,
2330 SourceLocation(),
2331 SourceLocation(), 0,
2332 FieldTypes[i], /*TInfo=*/0,
2333 /*BitWidth=*/0,
2334 /*Mutable=*/false,
Richard Smithca523302012-06-10 03:12:00 +00002335 ICIS_NoInit);
Douglas Gregor0815b572011-08-09 17:23:49 +00002336 Field->setAccess(AS_public);
2337 D->addDecl(Field);
2338 }
2339
2340 D->completeDefinition();
2341 ObjCFastEnumerationStateType = Context.getTagDeclType(D);
2342 }
2343
2344 return ObjCFastEnumerationStateType;
2345}
2346
Eli Friedman64f45a22011-11-01 02:23:42 +00002347llvm::Constant *
2348CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) {
2349 assert(!E->getType()->isPointerType() && "Strings are always arrays");
2350
2351 // Don't emit it as the address of the string, emit the string data itself
2352 // as an inline array.
Chris Lattner812234b2012-02-06 22:47:00 +00002353 if (E->getCharByteWidth() == 1) {
2354 SmallString<64> Str(E->getString());
2355
2356 // Resize the string to the right size, which is indicated by its type.
2357 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
2358 Str.resize(CAT->getSize().getZExtValue());
2359 return llvm::ConstantDataArray::getString(VMContext, Str, false);
2360 }
Chris Lattner94010692012-02-05 02:30:40 +00002361
2362 llvm::ArrayType *AType =
2363 cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
2364 llvm::Type *ElemTy = AType->getElementType();
2365 unsigned NumElements = AType->getNumElements();
Chris Lattnerd79ed432012-02-06 22:52:04 +00002366
2367 // Wide strings have either 2-byte or 4-byte elements.
2368 if (ElemTy->getPrimitiveSizeInBits() == 16) {
2369 SmallVector<uint16_t, 32> Elements;
2370 Elements.reserve(NumElements);
2371
2372 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2373 Elements.push_back(E->getCodeUnit(i));
2374 Elements.resize(NumElements);
2375 return llvm::ConstantDataArray::get(VMContext, Elements);
Chris Lattner94010692012-02-05 02:30:40 +00002376 }
2377
Chris Lattnerd79ed432012-02-06 22:52:04 +00002378 assert(ElemTy->getPrimitiveSizeInBits() == 32);
2379 SmallVector<uint32_t, 32> Elements;
2380 Elements.reserve(NumElements);
2381
2382 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2383 Elements.push_back(E->getCodeUnit(i));
2384 Elements.resize(NumElements);
2385 return llvm::ConstantDataArray::get(VMContext, Elements);
Eli Friedman64f45a22011-11-01 02:23:42 +00002386}
2387
Daniel Dunbar61432932008-08-13 23:20:05 +00002388/// GetAddrOfConstantStringFromLiteral - Return a pointer to a
2389/// constant array for the given string literal.
2390llvm::Constant *
2391CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
John McCalla5e19c62011-08-04 01:03:22 +00002392 CharUnits Align = getContext().getTypeAlignInChars(S->getType());
Eli Friedman64f45a22011-11-01 02:23:42 +00002393 if (S->isAscii() || S->isUTF8()) {
Chris Lattner812234b2012-02-06 22:47:00 +00002394 SmallString<64> Str(S->getString());
2395
2396 // Resize the string to the right size, which is indicated by its type.
2397 const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType());
2398 Str.resize(CAT->getSize().getZExtValue());
2399 return GetAddrOfConstantString(Str, /*GlobalName*/ 0, Align.getQuantity());
Eli Friedman7eb79c12009-11-16 05:55:46 +00002400 }
Eli Friedman64f45a22011-11-01 02:23:42 +00002401
Chris Lattner812234b2012-02-06 22:47:00 +00002402 // FIXME: the following does not memoize wide strings.
Eli Friedman64f45a22011-11-01 02:23:42 +00002403 llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
2404 llvm::GlobalVariable *GV =
2405 new llvm::GlobalVariable(getModule(),C->getType(),
David Blaikie4e4d0842012-03-11 07:00:24 +00002406 !LangOpts.WritableStrings,
Eli Friedman64f45a22011-11-01 02:23:42 +00002407 llvm::GlobalValue::PrivateLinkage,
2408 C,".str");
Seth Cantrell7d6a7c02012-01-18 12:11:32 +00002409
Eli Friedman64f45a22011-11-01 02:23:42 +00002410 GV->setAlignment(Align.getQuantity());
2411 GV->setUnnamedAddr(true);
Eli Friedman64f45a22011-11-01 02:23:42 +00002412 return GV;
Daniel Dunbar61432932008-08-13 23:20:05 +00002413}
2414
Chris Lattnereaf2bb82009-02-24 22:18:39 +00002415/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
2416/// array for the given ObjCEncodeExpr node.
2417llvm::Constant *
2418CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
2419 std::string Str;
2420 getContext().getObjCEncodingForType(E->getEncodedType(), Str);
Eli Friedmana210f352009-03-07 20:17:55 +00002421
2422 return GetAddrOfConstantCString(Str);
Chris Lattnereaf2bb82009-02-24 22:18:39 +00002423}
2424
2425
Chris Lattnera7ad98f2008-02-11 00:02:17 +00002426/// GenerateWritableString -- Creates storage for a string literal.
John McCalla5e19c62011-08-04 01:03:22 +00002427static llvm::GlobalVariable *GenerateStringLiteral(StringRef str,
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002428 bool constant,
Daniel Dunbar5fabf9d2008-10-17 21:56:50 +00002429 CodeGenModule &CGM,
John McCalla5e19c62011-08-04 01:03:22 +00002430 const char *GlobalName,
2431 unsigned Alignment) {
Daniel Dunbar61432932008-08-13 23:20:05 +00002432 // Create Constant for this string literal. Don't add a '\0'.
Owen Anderson0032b272009-08-13 21:57:51 +00002433 llvm::Constant *C =
Chris Lattner94010692012-02-05 02:30:40 +00002434 llvm::ConstantDataArray::getString(CGM.getLLVMContext(), str, false);
Mike Stump1eb44332009-09-09 15:08:12 +00002435
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002436 // Create a global variable for this string
Rafael Espindola1257bc62011-01-10 22:34:03 +00002437 llvm::GlobalVariable *GV =
2438 new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
2439 llvm::GlobalValue::PrivateLinkage,
2440 C, GlobalName);
John McCalla5e19c62011-08-04 01:03:22 +00002441 GV->setAlignment(Alignment);
Rafael Espindola1257bc62011-01-10 22:34:03 +00002442 GV->setUnnamedAddr(true);
2443 return GV;
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002444}
2445
Daniel Dunbar61432932008-08-13 23:20:05 +00002446/// GetAddrOfConstantString - Returns a pointer to a character array
2447/// containing the literal. This contents are exactly that of the
2448/// given string, i.e. it will not be null terminated automatically;
2449/// see GetAddrOfConstantCString. Note that whether the result is
2450/// actually a pointer to an LLVM constant depends on
2451/// Feature.WriteableStrings.
2452///
2453/// The result has pointer to array type.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002454llvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str,
John McCalla5e19c62011-08-04 01:03:22 +00002455 const char *GlobalName,
2456 unsigned Alignment) {
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00002457 // Get the default prefix if a name wasn't specified.
2458 if (!GlobalName)
Chris Lattner95b851e2009-07-16 05:03:48 +00002459 GlobalName = ".str";
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00002460
2461 // Don't share any string literals if strings aren't constant.
David Blaikie4e4d0842012-03-11 07:00:24 +00002462 if (LangOpts.WritableStrings)
John McCalla5e19c62011-08-04 01:03:22 +00002463 return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment);
Mike Stump1eb44332009-09-09 15:08:12 +00002464
John McCalla5e19c62011-08-04 01:03:22 +00002465 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
Benjamin Kramer9de43422011-03-05 13:45:23 +00002466 ConstantStringMap.GetOrCreateValue(Str);
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002467
John McCalla5e19c62011-08-04 01:03:22 +00002468 if (llvm::GlobalVariable *GV = Entry.getValue()) {
2469 if (Alignment > GV->getAlignment()) {
2470 GV->setAlignment(Alignment);
2471 }
2472 return GV;
2473 }
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002474
2475 // Create a global variable for this.
Chris Lattner812234b2012-02-06 22:47:00 +00002476 llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName,
2477 Alignment);
John McCalla5e19c62011-08-04 01:03:22 +00002478 Entry.setValue(GV);
2479 return GV;
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002480}
Daniel Dunbar61432932008-08-13 23:20:05 +00002481
2482/// GetAddrOfConstantCString - Returns a pointer to a character
Benjamin Kramer9de43422011-03-05 13:45:23 +00002483/// array containing the literal and a terminating '\0'
Daniel Dunbar61432932008-08-13 23:20:05 +00002484/// character. The result has pointer to array type.
Benjamin Kramer9de43422011-03-05 13:45:23 +00002485llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str,
John McCalla5e19c62011-08-04 01:03:22 +00002486 const char *GlobalName,
2487 unsigned Alignment) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00002488 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
John McCalla5e19c62011-08-04 01:03:22 +00002489 return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment);
Daniel Dunbar61432932008-08-13 23:20:05 +00002490}
Daniel Dunbar41071de2008-08-15 23:26:23 +00002491
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002492/// EmitObjCPropertyImplementations - Emit information for synthesized
2493/// properties for an implementation.
Mike Stump1eb44332009-09-09 15:08:12 +00002494void CodeGenModule::EmitObjCPropertyImplementations(const
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002495 ObjCImplementationDecl *D) {
Mike Stump1eb44332009-09-09 15:08:12 +00002496 for (ObjCImplementationDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002497 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +00002498 ObjCPropertyImplDecl *PID = *i;
Mike Stump1eb44332009-09-09 15:08:12 +00002499
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002500 // Dynamic is just for type-checking.
2501 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
2502 ObjCPropertyDecl *PD = PID->getPropertyDecl();
2503
2504 // Determine which methods need to be implemented, some may have
Jordan Rose1e4691b2012-10-10 16:42:25 +00002505 // been overridden. Note that ::isPropertyAccessor is not the method
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002506 // we want, that just indicates if the decl came from a
2507 // property. What we want to know is if the method is defined in
2508 // this implementation.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002509 if (!D->getInstanceMethod(PD->getGetterName()))
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00002510 CodeGenFunction(*this).GenerateObjCGetter(
2511 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002512 if (!PD->isReadOnly() &&
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002513 !D->getInstanceMethod(PD->getSetterName()))
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00002514 CodeGenFunction(*this).GenerateObjCSetter(
2515 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002516 }
2517 }
2518}
2519
John McCalle81ac692011-03-22 07:05:39 +00002520static bool needsDestructMethod(ObjCImplementationDecl *impl) {
Jordy Rosedb8264e2011-07-22 02:08:32 +00002521 const ObjCInterfaceDecl *iface = impl->getClassInterface();
2522 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
John McCalle81ac692011-03-22 07:05:39 +00002523 ivar; ivar = ivar->getNextIvar())
2524 if (ivar->getType().isDestructedType())
2525 return true;
2526
2527 return false;
2528}
2529
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002530/// EmitObjCIvarInitializations - Emit information for ivar initialization
2531/// for an implementation.
2532void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
John McCalle81ac692011-03-22 07:05:39 +00002533 // We might need a .cxx_destruct even if we don't have any ivar initializers.
2534 if (needsDestructMethod(D)) {
2535 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
2536 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
2537 ObjCMethodDecl *DTORMethod =
2538 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002539 cxxSelector, getContext().VoidTy, 0, D,
2540 /*isInstance=*/true, /*isVariadic=*/false,
Jordan Rose1e4691b2012-10-10 16:42:25 +00002541 /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002542 /*isDefined=*/false, ObjCMethodDecl::Required);
John McCalle81ac692011-03-22 07:05:39 +00002543 D->addInstanceMethod(DTORMethod);
2544 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
John McCallb03527a2012-10-17 04:53:31 +00002545 D->setHasDestructors(true);
John McCalle81ac692011-03-22 07:05:39 +00002546 }
2547
2548 // If the implementation doesn't have any ivar initializers, we don't need
2549 // a .cxx_construct.
David Chisnall827bbcc2011-03-17 14:19:08 +00002550 if (D->getNumIvarInitializers() == 0)
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002551 return;
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002552
John McCalle81ac692011-03-22 07:05:39 +00002553 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
2554 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002555 // The constructor returns 'self'.
2556 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
2557 D->getLocation(),
Argyrios Kyrtzidis11d77162011-10-03 06:36:36 +00002558 D->getLocation(),
Argyrios Kyrtzidis11d77162011-10-03 06:36:36 +00002559 cxxSelector,
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002560 getContext().getObjCIdType(), 0,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002561 D, /*isInstance=*/true,
2562 /*isVariadic=*/false,
Jordan Rose1e4691b2012-10-10 16:42:25 +00002563 /*isPropertyAccessor=*/true,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002564 /*isImplicitlyDeclared=*/true,
2565 /*isDefined=*/false,
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002566 ObjCMethodDecl::Required);
2567 D->addInstanceMethod(CTORMethod);
2568 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
John McCallb03527a2012-10-17 04:53:31 +00002569 D->setHasNonZeroConstructors(true);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002570}
2571
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002572/// EmitNamespace - Emit all declarations in a namespace.
Anders Carlsson984e0682009-04-01 00:58:25 +00002573void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002574 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
Anders Carlsson984e0682009-04-01 00:58:25 +00002575 I != E; ++I)
2576 EmitTopLevelDecl(*I);
2577}
2578
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002579// EmitLinkageSpec - Emit all declarations in a linkage spec.
2580void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
Eli Friedmanf976be82009-08-01 20:48:04 +00002581 if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
2582 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002583 ErrorUnsupported(LSD, "linkage spec");
2584 return;
2585 }
2586
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002587 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
Fariborz Jahanianc1868e52012-10-26 20:22:11 +00002588 I != E; ++I) {
Fariborz Jahanian107dae42012-10-26 22:20:25 +00002589 // Meta-data for ObjC class includes references to implemented methods.
2590 // Generate class's method definitions first.
Fariborz Jahanianc1868e52012-10-26 20:22:11 +00002591 if (ObjCImplDecl *OID = dyn_cast<ObjCImplDecl>(*I)) {
2592 for (ObjCContainerDecl::method_iterator M = OID->meth_begin(),
2593 MEnd = OID->meth_end();
2594 M != MEnd; ++M)
2595 EmitTopLevelDecl(*M);
2596 }
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002597 EmitTopLevelDecl(*I);
Fariborz Jahanianc1868e52012-10-26 20:22:11 +00002598 }
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002599}
2600
Daniel Dunbar41071de2008-08-15 23:26:23 +00002601/// EmitTopLevelDecl - Emit code for a single top level declaration.
2602void CodeGenModule::EmitTopLevelDecl(Decl *D) {
2603 // If an error has occurred, stop code generation, but continue
2604 // parsing and semantic analysis (to ensure all warnings and errors
2605 // are emitted).
2606 if (Diags.hasErrorOccurred())
2607 return;
2608
Douglas Gregor16e8be22009-06-29 17:30:29 +00002609 // Ignore dependent declarations.
2610 if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
2611 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002612
Daniel Dunbar41071de2008-08-15 23:26:23 +00002613 switch (D->getKind()) {
Anders Carlsson293361a2009-08-25 13:14:46 +00002614 case Decl::CXXConversion:
Anders Carlsson2b77ba82009-04-04 20:47:02 +00002615 case Decl::CXXMethod:
Daniel Dunbar41071de2008-08-15 23:26:23 +00002616 case Decl::Function:
Douglas Gregor16e8be22009-06-29 17:30:29 +00002617 // Skip function templates
Francois Pichet8387e2a2011-04-22 22:18:13 +00002618 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2619 cast<FunctionDecl>(D)->isLateTemplateParsed())
Douglas Gregor16e8be22009-06-29 17:30:29 +00002620 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002621
Anders Carlsson555b4bb2009-09-10 23:43:36 +00002622 EmitGlobal(cast<FunctionDecl>(D));
2623 break;
2624
Daniel Dunbar41071de2008-08-15 23:26:23 +00002625 case Decl::Var:
Anders Carlsson555b4bb2009-09-10 23:43:36 +00002626 EmitGlobal(cast<VarDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002627 break;
2628
John McCall26fbc722011-04-12 01:01:22 +00002629 // Indirect fields from global anonymous structs and unions can be
2630 // ignored; only the actual variable requires IR gen support.
2631 case Decl::IndirectField:
2632 break;
2633
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002634 // C++ Decls
Daniel Dunbar41071de2008-08-15 23:26:23 +00002635 case Decl::Namespace:
Anders Carlsson984e0682009-04-01 00:58:25 +00002636 EmitNamespace(cast<NamespaceDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002637 break;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002638 // No code generation needed.
John McCall9d0c6612009-11-17 09:33:40 +00002639 case Decl::UsingShadow:
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002640 case Decl::Using:
Douglas Gregordd9967a2009-09-02 23:49:23 +00002641 case Decl::UsingDirective:
Douglas Gregor127102b2009-06-29 20:59:39 +00002642 case Decl::ClassTemplate:
2643 case Decl::FunctionTemplate:
Richard Smith3e4c6c42011-05-05 21:57:07 +00002644 case Decl::TypeAliasTemplate:
Anders Carlsson018837b2009-09-23 19:19:16 +00002645 case Decl::NamespaceAlias:
Douglas Gregor6a576ab2011-06-05 05:04:23 +00002646 case Decl::Block:
Douglas Gregor15de72c2011-12-02 23:23:56 +00002647 case Decl::Import:
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002648 break;
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002649 case Decl::CXXConstructor:
Anders Carlsson1fe598c2009-11-24 05:16:24 +00002650 // Skip function templates
Francois Pichet8387e2a2011-04-22 22:18:13 +00002651 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2652 cast<FunctionDecl>(D)->isLateTemplateParsed())
Anders Carlsson1fe598c2009-11-24 05:16:24 +00002653 return;
2654
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002655 EmitCXXConstructors(cast<CXXConstructorDecl>(D));
2656 break;
Anders Carlsson27ae5362009-04-17 01:58:57 +00002657 case Decl::CXXDestructor:
Francois Pichet8387e2a2011-04-22 22:18:13 +00002658 if (cast<FunctionDecl>(D)->isLateTemplateParsed())
2659 return;
Anders Carlsson27ae5362009-04-17 01:58:57 +00002660 EmitCXXDestructors(cast<CXXDestructorDecl>(D));
2661 break;
Anders Carlsson36674d22009-06-11 21:22:55 +00002662
2663 case Decl::StaticAssert:
2664 // Nothing to do.
2665 break;
2666
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002667 // Objective-C Decls
Mike Stump1eb44332009-09-09 15:08:12 +00002668
Fariborz Jahanian38e24c72009-03-18 22:33:24 +00002669 // Forward declarations, no (immediate) code generation.
Chris Lattner285d0db2009-04-01 02:36:43 +00002670 case Decl::ObjCInterface:
Eric Christopherffb0c3a2012-07-19 22:22:55 +00002671 case Decl::ObjCCategory:
Chris Lattner285d0db2009-04-01 02:36:43 +00002672 break;
2673
Douglas Gregorbd9482d2012-01-01 21:23:57 +00002674 case Decl::ObjCProtocol: {
2675 ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(D);
2676 if (Proto->isThisDeclarationADefinition())
2677 ObjCRuntime->GenerateProtocol(Proto);
Daniel Dunbar41071de2008-08-15 23:26:23 +00002678 break;
Douglas Gregorbd9482d2012-01-01 21:23:57 +00002679 }
2680
Daniel Dunbar41071de2008-08-15 23:26:23 +00002681 case Decl::ObjCCategoryImpl:
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002682 // Categories have properties but don't support synthesize so we
2683 // can ignore them here.
Peter Collingbournee9265232011-07-27 20:29:46 +00002684 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002685 break;
2686
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002687 case Decl::ObjCImplementation: {
2688 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
2689 EmitObjCPropertyImplementations(OMD);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002690 EmitObjCIvarInitializations(OMD);
Peter Collingbournee9265232011-07-27 20:29:46 +00002691 ObjCRuntime->GenerateClass(OMD);
Eric Christopherbe6c6862012-04-11 05:56:05 +00002692 // Emit global variable debug information.
2693 if (CGDebugInfo *DI = getModuleDebugInfo())
Alexey Samsonov96a66392012-12-03 18:28:12 +00002694 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
2695 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
2696 OMD->getClassInterface()), OMD->getLocation());
Daniel Dunbar41071de2008-08-15 23:26:23 +00002697 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002698 }
Daniel Dunbar41071de2008-08-15 23:26:23 +00002699 case Decl::ObjCMethod: {
2700 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
2701 // If this is not a prototype, emit the body.
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +00002702 if (OMD->getBody())
Daniel Dunbar41071de2008-08-15 23:26:23 +00002703 CodeGenFunction(*this).GenerateObjCMethod(OMD);
2704 break;
2705 }
Mike Stump1eb44332009-09-09 15:08:12 +00002706 case Decl::ObjCCompatibleAlias:
David Chisnall29254f42012-01-31 18:59:20 +00002707 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002708 break;
2709
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002710 case Decl::LinkageSpec:
2711 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002712 break;
Daniel Dunbar41071de2008-08-15 23:26:23 +00002713
2714 case Decl::FileScopeAsm: {
2715 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
Chris Lattner5f9e2722011-07-23 10:55:15 +00002716 StringRef AsmString = AD->getAsmString()->getString();
Mike Stump1eb44332009-09-09 15:08:12 +00002717
Daniel Dunbar41071de2008-08-15 23:26:23 +00002718 const std::string &S = getModule().getModuleInlineAsm();
2719 if (S.empty())
2720 getModule().setModuleInlineAsm(AsmString);
Joerg Sonnenberger8ce9cca2012-08-10 10:57:52 +00002721 else if (S.end()[-1] == '\n')
Chris Lattner9f5bff02011-07-23 20:04:25 +00002722 getModule().setModuleInlineAsm(S + AsmString.str());
Daniel Dunbar41071de2008-08-15 23:26:23 +00002723 else
Benjamin Kramer8d042582009-12-11 13:33:18 +00002724 getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
Daniel Dunbar41071de2008-08-15 23:26:23 +00002725 break;
2726 }
Mike Stump1eb44332009-09-09 15:08:12 +00002727
2728 default:
Mike Stumpf5408fe2009-05-16 07:57:57 +00002729 // Make sure we handled everything we should, every other kind is a
2730 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
2731 // function. Need to recode Decl::Kind to do that easily.
Daniel Dunbar41071de2008-08-15 23:26:23 +00002732 assert(isa<TypeDecl>(D) && "Unsupported decl kind");
2733 }
2734}
John McCall744016d2010-07-06 23:57:41 +00002735
2736/// Turns the given pointer into a constant.
2737static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
2738 const void *Ptr) {
2739 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
Chris Lattner2acc6e32011-07-18 04:24:23 +00002740 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
John McCall744016d2010-07-06 23:57:41 +00002741 return llvm::ConstantInt::get(i64, PtrInt);
2742}
2743
2744static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
2745 llvm::NamedMDNode *&GlobalMetadata,
2746 GlobalDecl D,
2747 llvm::GlobalValue *Addr) {
2748 if (!GlobalMetadata)
2749 GlobalMetadata =
2750 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
2751
2752 // TODO: should we report variant information for ctors/dtors?
2753 llvm::Value *Ops[] = {
2754 Addr,
2755 GetPointerConstant(CGM.getLLVMContext(), D.getDecl())
2756 };
Jay Foad6f141652011-04-21 19:59:12 +00002757 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
John McCall744016d2010-07-06 23:57:41 +00002758}
2759
2760/// Emits metadata nodes associating all the global values in the
2761/// current module with the Decls they came from. This is useful for
2762/// projects using IR gen as a subroutine.
2763///
2764/// Since there's currently no way to associate an MDNode directly
2765/// with an llvm::GlobalValue, we create a global named metadata
2766/// with the name 'clang.global.decl.ptrs'.
2767void CodeGenModule::EmitDeclMetadata() {
2768 llvm::NamedMDNode *GlobalMetadata = 0;
2769
2770 // StaticLocalDeclMap
Chris Lattner5f9e2722011-07-23 10:55:15 +00002771 for (llvm::DenseMap<GlobalDecl,StringRef>::iterator
John McCall744016d2010-07-06 23:57:41 +00002772 I = MangledDeclNames.begin(), E = MangledDeclNames.end();
2773 I != E; ++I) {
2774 llvm::GlobalValue *Addr = getModule().getNamedValue(I->second);
2775 EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr);
2776 }
2777}
2778
2779/// Emits metadata nodes for all the local variables in the current
2780/// function.
2781void CodeGenFunction::EmitDeclMetadata() {
2782 if (LocalDeclMap.empty()) return;
2783
2784 llvm::LLVMContext &Context = getLLVMContext();
2785
2786 // Find the unique metadata ID for this name.
2787 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
2788
2789 llvm::NamedMDNode *GlobalMetadata = 0;
2790
2791 for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator
2792 I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) {
2793 const Decl *D = I->first;
2794 llvm::Value *Addr = I->second;
2795
2796 if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
2797 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
Jay Foad6f141652011-04-21 19:59:12 +00002798 Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr));
John McCall744016d2010-07-06 23:57:41 +00002799 } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
2800 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
2801 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
2802 }
2803 }
2804}
Daniel Dunbar673431a2010-07-16 00:00:15 +00002805
Nick Lewycky3dc05412011-05-05 00:08:20 +00002806void CodeGenModule::EmitCoverageFile() {
2807 if (!getCodeGenOpts().CoverageFile.empty()) {
Nick Lewycky5ea4f442011-05-04 20:46:58 +00002808 if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) {
2809 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
2810 llvm::LLVMContext &Ctx = TheModule.getContext();
Nick Lewycky3dc05412011-05-05 00:08:20 +00002811 llvm::MDString *CoverageFile =
2812 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile);
Nick Lewycky5ea4f442011-05-04 20:46:58 +00002813 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
2814 llvm::MDNode *CU = CUNode->getOperand(i);
Nick Lewycky3dc05412011-05-05 00:08:20 +00002815 llvm::Value *node[] = { CoverageFile, CU };
Nick Lewycky5ea4f442011-05-04 20:46:58 +00002816 llvm::MDNode *N = llvm::MDNode::get(Ctx, node);
2817 GCov->addOperand(N);
2818 }
2819 }
2820 }
2821}
Nico Weberc5f80462012-10-11 10:13:44 +00002822
2823llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid,
2824 QualType GuidType) {
2825 // Sema has checked that all uuid strings are of the form
2826 // "12345678-1234-1234-1234-1234567890ab".
2827 assert(Uuid.size() == 36);
2828 const char *Uuidstr = Uuid.data();
2829 for (int i = 0; i < 36; ++i) {
2830 if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuidstr[i] == '-');
2831 else assert(isxdigit(Uuidstr[i]));
2832 }
2833
2834 llvm::APInt Field0(32, StringRef(Uuidstr , 8), 16);
2835 llvm::APInt Field1(16, StringRef(Uuidstr + 9, 4), 16);
2836 llvm::APInt Field2(16, StringRef(Uuidstr + 14, 4), 16);
Nico Weber193646f2012-10-17 00:34:34 +00002837 static const int Field3ValueOffsets[] = { 19, 21, 24, 26, 28, 30, 32, 34 };
Nico Weberc5f80462012-10-11 10:13:44 +00002838
2839 APValue InitStruct(APValue::UninitStruct(), /*NumBases=*/0, /*NumFields=*/4);
2840 InitStruct.getStructField(0) = APValue(llvm::APSInt(Field0));
2841 InitStruct.getStructField(1) = APValue(llvm::APSInt(Field1));
2842 InitStruct.getStructField(2) = APValue(llvm::APSInt(Field2));
2843 APValue& Arr = InitStruct.getStructField(3);
2844 Arr = APValue(APValue::UninitArray(), 8, 8);
2845 for (int t = 0; t < 8; ++t)
Nico Weber43085812012-10-13 21:56:05 +00002846 Arr.getArrayInitializedElt(t) = APValue(llvm::APSInt(
2847 llvm::APInt(8, StringRef(Uuidstr + Field3ValueOffsets[t], 2), 16)));
Nico Weberc5f80462012-10-11 10:13:44 +00002848
2849 return EmitConstantValue(InitStruct, GuidType);
2850}