blob: 38f457ada69a8ccef98ffa0165ae5292d39f24c4 [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"
Douglas Gregorb6cbe512013-01-14 17:21:00 +000035#include "clang/Basic/Module.h"
Nate Begeman8bd4afe2008-04-19 04:17:09 +000036#include "clang/Basic/SourceManager.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000037#include "clang/Basic/TargetInfo.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000038#include "clang/Frontend/CodeGenOptions.h"
Sebastian Redl19b1a6e2012-02-25 20:51:20 +000039#include "llvm/ADT/APSInt.h"
John McCall6374c332010-03-06 00:35:14 +000040#include "llvm/ADT/Triple.h"
Chandler Carruth3b844ba2013-01-02 11:45:17 +000041#include "llvm/IR/CallingConv.h"
42#include "llvm/IR/DataLayout.h"
43#include "llvm/IR/Intrinsics.h"
44#include "llvm/IR/LLVMContext.h"
45#include "llvm/IR/Module.h"
Gabor Greif6ba728d2010-04-10 02:56:12 +000046#include "llvm/Support/CallSite.h"
Chris Lattner78f7ece2009-11-07 09:22:46 +000047#include "llvm/Support/ErrorHandling.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000048#include "llvm/Target/Mangler.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000049using namespace clang;
50using namespace CodeGen;
51
Julien Lerouge77f68bb2011-09-09 22:41:49 +000052static const char AnnotationSection[] = "llvm.metadata";
53
John McCallf16aa102010-08-22 21:01:12 +000054static CGCXXABI &createCXXABI(CodeGenModule &CGM) {
Douglas Gregorbcfd1f52011-09-02 00:18:52 +000055 switch (CGM.getContext().getTargetInfo().getCXXABI()) {
John McCallf16aa102010-08-22 21:01:12 +000056 case CXXABI_ARM: return *CreateARMCXXABI(CGM);
57 case CXXABI_Itanium: return *CreateItaniumCXXABI(CGM);
58 case CXXABI_Microsoft: return *CreateMicrosoftCXXABI(CGM);
59 }
60
61 llvm_unreachable("invalid C++ ABI kind");
John McCallf16aa102010-08-22 21:01:12 +000062}
63
Reid Spencer5f016e22007-07-11 17:01:13 +000064
Chandler Carruth2811ccf2009-11-12 17:24:48 +000065CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
Micah Villmow25a6a842012-10-08 16:25:52 +000066 llvm::Module &M, const llvm::DataLayout &TD,
David Blaikied6471f72011-09-25 23:23:43 +000067 DiagnosticsEngine &diags)
David Blaikie4e4d0842012-03-11 07:00:24 +000068 : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TheModule(M),
Micah Villmow25a6a842012-10-08 16:25:52 +000069 TheDataLayout(TD), TheTargetCodeGenInfo(0), Diags(diags),
John McCallf16aa102010-08-22 21:01:12 +000070 ABI(createCXXABI(*this)),
John McCallde5d3c72012-02-17 03:33:10 +000071 Types(*this),
Dan Gohman3d5aff52010-10-14 23:06:10 +000072 TBAA(0),
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +000073 VTables(*this), ObjCRuntime(0), OpenCLRuntime(0), CUDARuntime(0),
Dan Gohmanb49bd272012-02-16 00:57:37 +000074 DebugInfo(0), ARCData(0), NoObjCARCExceptionsMetadata(0),
75 RRData(0), CFConstantStringClassRef(0),
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +000076 ConstantStringClassRef(0), NSConstantStringType(0),
Daniel Dunbar673431a2010-07-16 00:00:15 +000077 VMContext(M.getContext()),
78 NSConcreteGlobalBlock(0), NSConcreteStackBlock(0),
John McCalld16c2cf2011-02-08 08:22:06 +000079 BlockObjectAssign(0), BlockObjectDispose(0),
80 BlockDescriptorType(0), GenericBlockLiteralType(0) {
Chris Lattner8b418682012-02-07 00:39:47 +000081
82 // Initialize the type cache.
83 llvm::LLVMContext &LLVMContext = M.getContext();
84 VoidTy = llvm::Type::getVoidTy(LLVMContext);
85 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
86 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
87 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
88 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
89 FloatTy = llvm::Type::getFloatTy(LLVMContext);
90 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
91 PointerWidthInBits = C.getTargetInfo().getPointerWidth(0);
92 PointerAlignInBytes =
93 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
94 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
95 IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits);
96 Int8PtrTy = Int8Ty->getPointerTo(0);
97 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
98
David Blaikie4e4d0842012-03-11 07:00:24 +000099 if (LangOpts.ObjC1)
Peter Collingbourne8c25fc52011-09-19 21:14:35 +0000100 createObjCRuntime();
David Blaikie4e4d0842012-03-11 07:00:24 +0000101 if (LangOpts.OpenCL)
Peter Collingbourne8c25fc52011-09-19 21:14:35 +0000102 createOpenCLRuntime();
David Blaikie4e4d0842012-03-11 07:00:24 +0000103 if (LangOpts.CUDA)
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +0000104 createCUDARuntime();
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +0000105
Kostya Serebryanyc9fe6052012-04-24 06:57:01 +0000106 // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
Richard Smithca1b62a2012-11-05 21:48:12 +0000107 if (LangOpts.SanitizeThread ||
Kostya Serebryanyc9fe6052012-04-24 06:57:01 +0000108 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
109 TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(),
Dan Gohman0b5c4fc2010-10-15 20:23:12 +0000110 ABI.getMangleContext());
Dan Gohman3d5aff52010-10-14 23:06:10 +0000111
Nick Lewyckye8ba8d72011-04-21 23:44:07 +0000112 // If debug info or coverage generation is enabled, create the CGDebugInfo
113 // object.
Douglas Gregor4cdad312012-10-23 20:05:01 +0000114 if (CodeGenOpts.getDebugInfo() != CodeGenOptions::NoDebugInfo ||
Alexey Samsonov3a70cd62012-04-27 07:24:20 +0000115 CodeGenOpts.EmitGcovArcs ||
Nick Lewyckye8ba8d72011-04-21 23:44:07 +0000116 CodeGenOpts.EmitGcovNotes)
117 DebugInfo = new CGDebugInfo(*this);
John McCalld16c2cf2011-02-08 08:22:06 +0000118
119 Block.GlobalUniqueCount = 0;
John McCall5936e332011-02-15 09:22:45 +0000120
David Blaikie4e4d0842012-03-11 07:00:24 +0000121 if (C.getLangOpts().ObjCAutoRefCount)
John McCallf85e1932011-06-15 23:02:42 +0000122 ARCData = new ARCEntrypoints();
123 RRData = new RREntrypoints();
Chris Lattner2b94fe32008-03-01 08:45:05 +0000124}
125
126CodeGenModule::~CodeGenModule() {
Peter Collingbournee9265232011-07-27 20:29:46 +0000127 delete ObjCRuntime;
Peter Collingbourne8c25fc52011-09-19 21:14:35 +0000128 delete OpenCLRuntime;
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +0000129 delete CUDARuntime;
Ted Kremenek0628b722011-10-08 05:28:26 +0000130 delete TheTargetCodeGenInfo;
John McCallf16aa102010-08-22 21:01:12 +0000131 delete &ABI;
Dan Gohman4376c852010-10-15 18:04:46 +0000132 delete TBAA;
Ted Kremenek815c78f2008-08-05 18:50:11 +0000133 delete DebugInfo;
John McCallf85e1932011-06-15 23:02:42 +0000134 delete ARCData;
135 delete RRData;
Ted Kremenek815c78f2008-08-05 18:50:11 +0000136}
137
David Chisnall0d13f6f2010-01-23 02:40:42 +0000138void CodeGenModule::createObjCRuntime() {
John McCall260611a2012-06-20 06:18:46 +0000139 // This is just isGNUFamily(), but we want to force implementors of
140 // new ABIs to decide how best to do this.
141 switch (LangOpts.ObjCRuntime.getKind()) {
David Chisnall11d3f4c2012-07-03 20:49:52 +0000142 case ObjCRuntime::GNUstep:
143 case ObjCRuntime::GCC:
John McCallf7226fb2012-07-12 02:07:58 +0000144 case ObjCRuntime::ObjFW:
Peter Collingbournee9265232011-07-27 20:29:46 +0000145 ObjCRuntime = CreateGNUObjCRuntime(*this);
John McCall260611a2012-06-20 06:18:46 +0000146 return;
147
148 case ObjCRuntime::FragileMacOSX:
149 case ObjCRuntime::MacOSX:
150 case ObjCRuntime::iOS:
Peter Collingbournee9265232011-07-27 20:29:46 +0000151 ObjCRuntime = CreateMacObjCRuntime(*this);
John McCall260611a2012-06-20 06:18:46 +0000152 return;
153 }
154 llvm_unreachable("bad runtime kind");
David Chisnall0d13f6f2010-01-23 02:40:42 +0000155}
156
Peter Collingbourne8c25fc52011-09-19 21:14:35 +0000157void CodeGenModule::createOpenCLRuntime() {
158 OpenCLRuntime = new CGOpenCLRuntime(*this);
159}
160
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +0000161void CodeGenModule::createCUDARuntime() {
162 CUDARuntime = CreateNVCUDARuntime(*this);
163}
164
Ted Kremenek815c78f2008-08-05 18:50:11 +0000165void CodeGenModule::Release() {
Chris Lattner82227ff2009-03-22 21:21:57 +0000166 EmitDeferred();
Eli Friedman6c6bda32010-01-08 00:50:11 +0000167 EmitCXXGlobalInitFunc();
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000168 EmitCXXGlobalDtorFunc();
Peter Collingbournee9265232011-07-27 20:29:46 +0000169 if (ObjCRuntime)
170 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
Daniel Dunbar208ff5e2008-08-11 18:12:00 +0000171 AddGlobalCtor(ObjCInitFunction);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000172 EmitCtorList(GlobalCtors, "llvm.global_ctors");
173 EmitCtorList(GlobalDtors, "llvm.global_dtors");
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000174 EmitGlobalAnnotations();
Daniel Dunbar02698712009-02-13 20:29:50 +0000175 EmitLLVMUsed();
Douglas Gregorf43b7212013-01-16 01:23:41 +0000176
177 if (CodeGenOpts.ModulesAutolink) {
178 EmitModuleLinkOptions();
179 }
Douglas Gregor5d75ea72013-01-14 18:28:43 +0000180
John McCallb2593832010-09-16 06:16:50 +0000181 SimplifyPersonality();
182
John McCall744016d2010-07-06 23:57:41 +0000183 if (getCodeGenOpts().EmitDeclMetadata)
184 EmitDeclMetadata();
Nick Lewycky5ea4f442011-05-04 20:46:58 +0000185
186 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
Nick Lewycky3dc05412011-05-05 00:08:20 +0000187 EmitCoverageFile();
Devang Patelf391dbe2011-08-16 20:58:22 +0000188
189 if (DebugInfo)
190 DebugInfo->finalize();
Daniel Dunbarf1968f22008-10-01 00:49:24 +0000191}
192
Devang Patele80d5672011-03-23 16:29:39 +0000193void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
194 // Make sure that this type is translated.
195 Types.UpdateCompletedType(TD);
Devang Patele80d5672011-03-23 16:29:39 +0000196}
197
Dan Gohman3d5aff52010-10-14 23:06:10 +0000198llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) {
199 if (!TBAA)
200 return 0;
201 return TBAA->getTBAAInfo(QTy);
202}
203
Kostya Serebryany8cb4a072012-03-26 17:03:51 +0000204llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() {
205 if (!TBAA)
206 return 0;
207 return TBAA->getTBAAInfoForVTablePtr();
208}
209
Dan Gohmanb22c7dc2012-09-28 21:58:29 +0000210llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) {
211 if (!TBAA)
212 return 0;
213 return TBAA->getTBAAStructInfo(QTy);
214}
215
Dan Gohman3d5aff52010-10-14 23:06:10 +0000216void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst,
217 llvm::MDNode *TBAAInfo) {
218 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo);
219}
220
John McCall6374c332010-03-06 00:35:14 +0000221bool CodeGenModule::isTargetDarwin() const {
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000222 return getContext().getTargetInfo().getTriple().isOSDarwin();
John McCall6374c332010-03-06 00:35:14 +0000223}
224
Chandler Carruth0f30a122012-03-30 19:44:53 +0000225void CodeGenModule::Error(SourceLocation loc, StringRef error) {
226 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, error);
John McCall32096692011-03-18 02:56:14 +0000227 getDiags().Report(Context.getFullLoc(loc), diagID);
228}
229
Daniel Dunbar488e9932008-08-16 00:56:44 +0000230/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattner2c8569d2007-12-02 07:19:18 +0000231/// specified stmt yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000232void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
233 bool OmitOnError) {
234 if (OmitOnError && getDiags().hasErrorOccurred())
235 return;
David Blaikied6471f72011-09-25 23:23:43 +0000236 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
Daniel Dunbar56b80012009-02-06 19:18:03 +0000237 "cannot compile this %0 yet");
Chris Lattner2c8569d2007-12-02 07:19:18 +0000238 std::string Msg = Type;
Chris Lattner0a14eee2008-11-18 07:04:44 +0000239 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
240 << Msg << S->getSourceRange();
Chris Lattner2c8569d2007-12-02 07:19:18 +0000241}
Chris Lattner58c3f9e2007-12-02 06:27:33 +0000242
Daniel Dunbar488e9932008-08-16 00:56:44 +0000243/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000244/// specified decl yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000245void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
246 bool OmitOnError) {
247 if (OmitOnError && getDiags().hasErrorOccurred())
248 return;
David Blaikied6471f72011-09-25 23:23:43 +0000249 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
Daniel Dunbar56b80012009-02-06 19:18:03 +0000250 "cannot compile this %0 yet");
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000251 std::string Msg = Type;
Chris Lattner0a14eee2008-11-18 07:04:44 +0000252 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000253}
254
John McCallbc8d40d2011-06-24 21:55:10 +0000255llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
256 return llvm::ConstantInt::get(SizeTy, size.getQuantity());
257}
258
Mike Stump1eb44332009-09-09 15:08:12 +0000259void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
Anders Carlsson0ffeaad2011-01-29 19:39:23 +0000260 const NamedDecl *D) const {
Daniel Dunbar04d40782009-04-14 06:00:08 +0000261 // Internal definitions always have default visibility.
Chris Lattnerdf102fc2009-04-14 05:27:13 +0000262 if (GV->hasLocalLinkage()) {
Daniel Dunbar7e714cd2009-04-10 20:26:50 +0000263 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar6ab187a2009-04-07 05:48:37 +0000264 return;
Daniel Dunbar7e714cd2009-04-10 20:26:50 +0000265 }
Daniel Dunbar6ab187a2009-04-07 05:48:37 +0000266
John McCallaf146032010-10-30 11:50:40 +0000267 // Set visibility for definitions.
268 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility();
Fariborz Jahanianc7c90582011-06-16 20:14:50 +0000269 if (LV.visibilityExplicit() || !GV->hasAvailableExternallyLinkage())
270 GV->setVisibility(GetLLVMVisibility(LV.visibility()));
Dan Gohman4f8d1232008-05-22 00:50:06 +0000271}
272
Hans Wennborgde981f32012-06-28 08:01:44 +0000273static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
274 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
275 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
276 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
277 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
278 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
279}
280
281static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
282 CodeGenOptions::TLSModel M) {
283 switch (M) {
284 case CodeGenOptions::GeneralDynamicTLSModel:
285 return llvm::GlobalVariable::GeneralDynamicTLSModel;
286 case CodeGenOptions::LocalDynamicTLSModel:
287 return llvm::GlobalVariable::LocalDynamicTLSModel;
288 case CodeGenOptions::InitialExecTLSModel:
289 return llvm::GlobalVariable::InitialExecTLSModel;
290 case CodeGenOptions::LocalExecTLSModel:
291 return llvm::GlobalVariable::LocalExecTLSModel;
292 }
293 llvm_unreachable("Invalid TLS model!");
294}
295
296void CodeGenModule::setTLSMode(llvm::GlobalVariable *GV,
297 const VarDecl &D) const {
298 assert(D.isThreadSpecified() && "setting TLS mode on non-TLS var!");
299
300 llvm::GlobalVariable::ThreadLocalMode TLM;
Douglas Gregor4cdad312012-10-23 20:05:01 +0000301 TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel());
Hans Wennborgde981f32012-06-28 08:01:44 +0000302
303 // Override the TLS model if it is explicitly specified.
304 if (D.hasAttr<TLSModelAttr>()) {
305 const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>();
306 TLM = GetLLVMTLSModel(Attr->getModel());
307 }
308
309 GV->setThreadLocalMode(TLM);
310}
311
John McCallcbfe5022010-08-04 08:34:44 +0000312/// Set the symbol visibility of type information (vtable and RTTI)
313/// associated with the given type.
314void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV,
315 const CXXRecordDecl *RD,
Anders Carlssonfa2e99f2011-01-29 20:24:48 +0000316 TypeVisibilityKind TVK) const {
Anders Carlsson0ffeaad2011-01-29 19:39:23 +0000317 setGlobalVisibility(GV, RD);
John McCallcbfe5022010-08-04 08:34:44 +0000318
John McCall279b5eb2010-08-12 23:36:15 +0000319 if (!CodeGenOpts.HiddenWeakVTables)
320 return;
321
Anders Carlsson9a86a132011-01-29 20:36:11 +0000322 // We never want to drop the visibility for RTTI names.
323 if (TVK == TVK_ForRTTIName)
324 return;
325
John McCallcbfe5022010-08-04 08:34:44 +0000326 // We want to drop the visibility to hidden for weak type symbols.
327 // This isn't possible if there might be unresolved references
328 // elsewhere that rely on this symbol being visible.
329
John McCall7a536902010-08-05 20:39:18 +0000330 // This should be kept roughly in sync with setThunkVisibility
331 // in CGVTables.cpp.
332
John McCallcbfe5022010-08-04 08:34:44 +0000333 // Preconditions.
Anders Carlssonf502d932011-01-24 00:46:19 +0000334 if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage ||
John McCallcbfe5022010-08-04 08:34:44 +0000335 GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
336 return;
337
338 // Don't override an explicit visibility attribute.
Douglas Gregor4421d2b2011-03-26 12:10:19 +0000339 if (RD->getExplicitVisibility())
John McCallcbfe5022010-08-04 08:34:44 +0000340 return;
341
342 switch (RD->getTemplateSpecializationKind()) {
343 // We have to disable the optimization if this is an EI definition
344 // because there might be EI declarations in other shared objects.
345 case TSK_ExplicitInstantiationDefinition:
346 case TSK_ExplicitInstantiationDeclaration:
347 return;
348
John McCall7a536902010-08-05 20:39:18 +0000349 // Every use of a non-template class's type information has to emit it.
John McCallcbfe5022010-08-04 08:34:44 +0000350 case TSK_Undeclared:
351 break;
352
John McCall7a536902010-08-05 20:39:18 +0000353 // In theory, implicit instantiations can ignore the possibility of
354 // an explicit instantiation declaration because there necessarily
355 // must be an EI definition somewhere with default visibility. In
356 // practice, it's possible to have an explicit instantiation for
357 // an arbitrary template class, and linkers aren't necessarily able
358 // to deal with mixed-visibility symbols.
359 case TSK_ExplicitSpecialization:
John McCallcbfe5022010-08-04 08:34:44 +0000360 case TSK_ImplicitInstantiation:
Douglas Gregoraafd1112012-10-24 14:11:55 +0000361 return;
John McCallcbfe5022010-08-04 08:34:44 +0000362 }
363
364 // If there's a key function, there may be translation units
365 // that don't have the key function's definition. But ignore
366 // this if we're emitting RTTI under -fno-rtti.
David Blaikie4e4d0842012-03-11 07:00:24 +0000367 if (!(TVK != TVK_ForRTTI) || LangOpts.RTTI) {
John McCallcbfe5022010-08-04 08:34:44 +0000368 if (Context.getKeyFunction(RD))
369 return;
Anders Carlssonfa2e99f2011-01-29 20:24:48 +0000370 }
John McCallcbfe5022010-08-04 08:34:44 +0000371
372 // Otherwise, drop the visibility to hidden.
373 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Rafael Espindolab1c65ff2011-01-11 21:44:37 +0000374 GV->setUnnamedAddr(true);
John McCallcbfe5022010-08-04 08:34:44 +0000375}
376
Chris Lattner5f9e2722011-07-23 10:55:15 +0000377StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
Anders Carlsson793a9902010-06-22 16:05:32 +0000378 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
379
Chris Lattner5f9e2722011-07-23 10:55:15 +0000380 StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()];
Anders Carlsson793a9902010-06-22 16:05:32 +0000381 if (!Str.empty())
382 return Str;
383
John McCall4c40d982010-08-31 07:33:07 +0000384 if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
Anders Carlsson793a9902010-06-22 16:05:32 +0000385 IdentifierInfo *II = ND->getIdentifier();
386 assert(II && "Attempt to mangle unnamed decl.");
387
388 Str = II->getName();
389 return Str;
390 }
391
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000392 SmallString<256> Buffer;
Rafael Espindolac4850c22011-02-10 23:59:36 +0000393 llvm::raw_svector_ostream Out(Buffer);
Anders Carlsson793a9902010-06-22 16:05:32 +0000394 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000395 getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000396 else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000397 getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000398 else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND))
Fariborz Jahanian4904bf42012-06-26 16:06:38 +0000399 getCXXABI().getMangleContext().mangleBlock(BD, Out,
400 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()));
Anders Carlsson793a9902010-06-22 16:05:32 +0000401 else
Rafael Espindolac4850c22011-02-10 23:59:36 +0000402 getCXXABI().getMangleContext().mangleName(ND, Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000403
404 // Allocate space for the mangled name.
Rafael Espindolac4850c22011-02-10 23:59:36 +0000405 Out.flush();
Anders Carlsson793a9902010-06-22 16:05:32 +0000406 size_t Length = Buffer.size();
407 char *Name = MangledNamesAllocator.Allocate<char>(Length);
408 std::copy(Buffer.begin(), Buffer.end(), Name);
409
Chris Lattner5f9e2722011-07-23 10:55:15 +0000410 Str = StringRef(Name, Length);
Anders Carlsson793a9902010-06-22 16:05:32 +0000411
412 return Str;
413}
414
Peter Collingbourne14110472011-01-13 18:57:25 +0000415void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer,
416 const BlockDecl *BD) {
417 MangleContext &MangleCtx = getCXXABI().getMangleContext();
418 const Decl *D = GD.getDecl();
Rafael Espindolac4850c22011-02-10 23:59:36 +0000419 llvm::raw_svector_ostream Out(Buffer.getBuffer());
Peter Collingbourne14110472011-01-13 18:57:25 +0000420 if (D == 0)
Fariborz Jahanian4904bf42012-06-26 16:06:38 +0000421 MangleCtx.mangleGlobalBlock(BD,
422 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
Peter Collingbourne14110472011-01-13 18:57:25 +0000423 else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000424 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
Peter Collingbourne14110472011-01-13 18:57:25 +0000425 else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000426 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
Peter Collingbourne14110472011-01-13 18:57:25 +0000427 else
Rafael Espindolac4850c22011-02-10 23:59:36 +0000428 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
Anders Carlsson9a8822b2010-06-09 02:36:32 +0000429}
430
Chris Lattner5f9e2722011-07-23 10:55:15 +0000431llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
John McCallf746aa62010-03-19 23:29:14 +0000432 return getModule().getNamedValue(Name);
Douglas Gregor5f2bfd42009-02-13 00:10:09 +0000433}
434
Chris Lattner6d397602008-03-14 17:18:18 +0000435/// AddGlobalCtor - Add a function to the list that will be called before
436/// main() runs.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000437void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
Daniel Dunbar49988882009-01-13 02:25:00 +0000438 // FIXME: Type coercion of void()* types.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000439 GlobalCtors.push_back(std::make_pair(Ctor, Priority));
Chris Lattner6d397602008-03-14 17:18:18 +0000440}
441
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000442/// AddGlobalDtor - Add a function to the list that will be called
443/// when the module is unloaded.
444void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
Daniel Dunbar49988882009-01-13 02:25:00 +0000445 // FIXME: Type coercion of void()* types.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000446 GlobalDtors.push_back(std::make_pair(Dtor, Priority));
447}
448
449void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
450 // Ctor function type is void()*.
John McCall0774cb82011-05-15 01:53:33 +0000451 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000452 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000453
454 // Get the type of a ctor entry, { i32, void ()* }.
Chris Lattnerc5cbb902011-06-20 04:01:35 +0000455 llvm::StructType *CtorStructTy =
Chris Lattner8b418682012-02-07 00:39:47 +0000456 llvm::StructType::get(Int32Ty, llvm::PointerType::getUnqual(CtorFTy), NULL);
Chris Lattner6d397602008-03-14 17:18:18 +0000457
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000458 // Construct the constructor and destructor arrays.
Chris Lattner0b239712012-02-06 22:16:34 +0000459 SmallVector<llvm::Constant*, 8> Ctors;
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000460 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
Chris Lattner0b239712012-02-06 22:16:34 +0000461 llvm::Constant *S[] = {
462 llvm::ConstantInt::get(Int32Ty, I->second, false),
463 llvm::ConstantExpr::getBitCast(I->first, CtorPFTy)
464 };
Owen Anderson08e25242009-07-27 22:29:56 +0000465 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
Chris Lattner6d397602008-03-14 17:18:18 +0000466 }
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000467
468 if (!Ctors.empty()) {
Owen Anderson96e0fc72009-07-29 22:16:19 +0000469 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
Owen Anderson1c431b32009-07-08 19:05:04 +0000470 new llvm::GlobalVariable(TheModule, AT, false,
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000471 llvm::GlobalValue::AppendingLinkage,
Owen Anderson7db6d832009-07-28 18:33:04 +0000472 llvm::ConstantArray::get(AT, Ctors),
Owen Anderson1c431b32009-07-08 19:05:04 +0000473 GlobalName);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000474 }
Chris Lattner6d397602008-03-14 17:18:18 +0000475}
476
John McCalld46f9852010-02-19 01:32:20 +0000477llvm::GlobalValue::LinkageTypes
478CodeGenModule::getFunctionLinkage(const FunctionDecl *D) {
Argyrios Kyrtzidis90e99a82010-07-29 18:15:58 +0000479 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000480
Chris Lattnerf81530652010-06-30 16:58:07 +0000481 if (Linkage == GVA_Internal)
John McCalld46f9852010-02-19 01:32:20 +0000482 return llvm::Function::InternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000483
484 if (D->hasAttr<DLLExportAttr>())
John McCalld46f9852010-02-19 01:32:20 +0000485 return llvm::Function::DLLExportLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000486
487 if (D->hasAttr<WeakAttr>())
John McCalld46f9852010-02-19 01:32:20 +0000488 return llvm::Function::WeakAnyLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000489
490 // In C99 mode, 'inline' functions are guaranteed to have a strong
491 // definition somewhere else, so we can use available_externally linkage.
492 if (Linkage == GVA_C99Inline)
Fariborz Jahanianfd0f89d2011-02-04 00:08:13 +0000493 return llvm::Function::AvailableExternallyLinkage;
John McCall5584d912011-09-19 18:05:26 +0000494
495 // Note that Apple's kernel linker doesn't support symbol
496 // coalescing, so we need to avoid linkonce and weak linkages there.
497 // Normally, this means we just map to internal, but for explicit
498 // instantiations we'll map to external.
499
Chris Lattnerf81530652010-06-30 16:58:07 +0000500 // In C++, the compiler has to emit a definition in every translation unit
501 // that references the function. We should use linkonce_odr because
502 // a) if all references in this translation unit are optimized away, we
503 // don't need to codegen it. b) if the function persists, it needs to be
504 // merged with other definitions. c) C++ has the ODR, so we know the
505 // definition is dependable.
506 if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
David Blaikie4e4d0842012-03-11 07:00:24 +0000507 return !Context.getLangOpts().AppleKext
Fariborz Jahanian142f9e92011-02-04 00:01:24 +0000508 ? llvm::Function::LinkOnceODRLinkage
509 : llvm::Function::InternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000510
511 // An explicit instantiation of a template has weak linkage, since
512 // explicit instantiations can occur in multiple translation units
513 // and must all be equivalent. However, we are not allowed to
514 // throw away these explicit instantiations.
515 if (Linkage == GVA_ExplicitTemplateInstantiation)
David Blaikie4e4d0842012-03-11 07:00:24 +0000516 return !Context.getLangOpts().AppleKext
Fariborz Jahanian142f9e92011-02-04 00:01:24 +0000517 ? llvm::Function::WeakODRLinkage
John McCall5584d912011-09-19 18:05:26 +0000518 : llvm::Function::ExternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000519
520 // Otherwise, we have strong external linkage.
521 assert(Linkage == GVA_StrongExternal);
522 return llvm::Function::ExternalLinkage;
John McCalld46f9852010-02-19 01:32:20 +0000523}
Nuno Lopesd4cbda62008-06-08 15:45:52 +0000524
John McCalld46f9852010-02-19 01:32:20 +0000525
526/// SetFunctionDefinitionAttributes - Set attributes for a global.
527///
528/// FIXME: This is currently only done for aliases and functions, but not for
529/// variables (these details are set in EmitGlobalVarDefinition for variables).
530void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
531 llvm::GlobalValue *GV) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000532 SetCommonAttributes(D, GV);
Nuno Lopesd4cbda62008-06-08 15:45:52 +0000533}
534
Daniel Dunbar7dbd8192009-04-14 07:08:30 +0000535void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
Mike Stump1eb44332009-09-09 15:08:12 +0000536 const CGFunctionInfo &Info,
Daniel Dunbar7dbd8192009-04-14 07:08:30 +0000537 llvm::Function *F) {
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000538 unsigned CallingConv;
Devang Patel761d7f72008-09-25 21:02:23 +0000539 AttributeListType AttributeList;
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000540 ConstructAttributeList(Info, D, AttributeList, CallingConv);
Bill Wendling785b7782012-12-07 23:17:26 +0000541 F->setAttributes(llvm::AttributeSet::get(getLLVMContext(), AttributeList));
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000542 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000543}
544
John McCalld1e40d52011-10-02 01:16:38 +0000545/// Determines whether the language options require us to model
546/// unwind exceptions. We treat -fexceptions as mandating this
547/// except under the fragile ObjC ABI with only ObjC exceptions
548/// enabled. This means, for example, that C with -fexceptions
549/// enables this.
David Blaikie4e4d0842012-03-11 07:00:24 +0000550static bool hasUnwindExceptions(const LangOptions &LangOpts) {
John McCalld1e40d52011-10-02 01:16:38 +0000551 // If exceptions are completely disabled, obviously this is false.
David Blaikie4e4d0842012-03-11 07:00:24 +0000552 if (!LangOpts.Exceptions) return false;
John McCalld1e40d52011-10-02 01:16:38 +0000553
554 // If C++ exceptions are enabled, this is true.
David Blaikie4e4d0842012-03-11 07:00:24 +0000555 if (LangOpts.CXXExceptions) return true;
John McCalld1e40d52011-10-02 01:16:38 +0000556
557 // If ObjC exceptions are enabled, this depends on the ABI.
David Blaikie4e4d0842012-03-11 07:00:24 +0000558 if (LangOpts.ObjCExceptions) {
David Chisnall11d3f4c2012-07-03 20:49:52 +0000559 return LangOpts.ObjCRuntime.hasUnwindExceptions();
John McCalld1e40d52011-10-02 01:16:38 +0000560 }
561
562 return true;
563}
564
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000565void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
566 llvm::Function *F) {
Rafael Espindolaabca5a12011-05-25 03:44:55 +0000567 if (CodeGenOpts.UnwindTables)
568 F->setHasUWTable();
569
David Blaikie4e4d0842012-03-11 07:00:24 +0000570 if (!hasUnwindExceptions(LangOpts))
Bill Wendling72390b32012-12-20 19:27:06 +0000571 F->addFnAttr(llvm::Attribute::NoUnwind);
Daniel Dunbaraf668b02008-10-28 00:17:57 +0000572
Eli Friedman2873aee2011-08-22 23:55:33 +0000573 if (D->hasAttr<NakedAttr>()) {
574 // Naked implies noinline: we should not be inlining such functions.
Bill Wendling72390b32012-12-20 19:27:06 +0000575 F->addFnAttr(llvm::Attribute::Naked);
576 F->addFnAttr(llvm::Attribute::NoInline);
Eli Friedman2873aee2011-08-22 23:55:33 +0000577 }
Daniel Dunbardd0cb222010-09-29 18:20:25 +0000578
Mike Stump1feade82009-08-26 22:31:08 +0000579 if (D->hasAttr<NoInlineAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +0000580 F->addFnAttr(llvm::Attribute::NoInline);
Mike Stumpf55314d2009-10-05 21:58:44 +0000581
Eli Friedman2873aee2011-08-22 23:55:33 +0000582 // (noinline wins over always_inline, and we can't specify both in IR)
Michael J. Spenceradc6cbf2012-06-18 07:00:48 +0000583 if ((D->hasAttr<AlwaysInlineAttr>() || D->hasAttr<ForceInlineAttr>()) &&
Bill Wendling01ad9542012-12-30 10:32:17 +0000584 !F->getAttributes().hasAttribute(llvm::AttributeSet::FunctionIndex,
585 llvm::Attribute::NoInline))
Bill Wendling72390b32012-12-20 19:27:06 +0000586 F->addFnAttr(llvm::Attribute::AlwaysInline);
Eli Friedman2873aee2011-08-22 23:55:33 +0000587
Benjamin Krameree409a92012-05-12 21:10:52 +0000588 // FIXME: Communicate hot and cold attributes to LLVM more directly.
589 if (D->hasAttr<ColdAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +0000590 F->addFnAttr(llvm::Attribute::OptimizeForSize);
Benjamin Krameree409a92012-05-12 21:10:52 +0000591
Quentin Colombetaee56fa2012-11-01 23:55:47 +0000592 if (D->hasAttr<MinSizeAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +0000593 F->addFnAttr(llvm::Attribute::MinSize);
Quentin Colombetaee56fa2012-11-01 23:55:47 +0000594
Rafael Espindolac5f657f2011-01-11 00:26:26 +0000595 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
596 F->setUnnamedAddr(true);
597
Richard Smithef4d5ce2012-09-28 22:46:07 +0000598 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D))
599 if (MD->isVirtual())
600 F->setUnnamedAddr(true);
601
David Blaikie4e4d0842012-03-11 07:00:24 +0000602 if (LangOpts.getStackProtector() == LangOptions::SSPOn)
Bill Wendling72390b32012-12-20 19:27:06 +0000603 F->addFnAttr(llvm::Attribute::StackProtect);
David Blaikie4e4d0842012-03-11 07:00:24 +0000604 else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
Bill Wendling72390b32012-12-20 19:27:06 +0000605 F->addFnAttr(llvm::Attribute::StackProtectReq);
Anders Carlssonfd015352009-11-16 16:56:03 +0000606
Richard Smithca1b62a2012-11-05 21:48:12 +0000607 if (LangOpts.SanitizeAddress) {
Alexander Potapenko89651ea2012-02-02 11:49:28 +0000608 // When AddressSanitizer is enabled, set AddressSafety attribute
609 // unless __attribute__((no_address_safety_analysis)) is used.
610 if (!D->hasAttr<NoAddressSafetyAnalysisAttr>())
Bill Wendling72390b32012-12-20 19:27:06 +0000611 F->addFnAttr(llvm::Attribute::AddressSafety);
Alexander Potapenko89651ea2012-02-02 11:49:28 +0000612 }
613
Sean Huntcf807c42010-08-18 23:23:40 +0000614 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
615 if (alignment)
616 F->setAlignment(alignment);
617
Mike Stumpfb51ddf2009-10-05 22:49:20 +0000618 // C++ ABI requires 2-byte alignment for member functions.
Mike Stumpbd6dbd12009-10-05 23:08:21 +0000619 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
620 F->setAlignment(2);
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000621}
622
Mike Stump1eb44332009-09-09 15:08:12 +0000623void CodeGenModule::SetCommonAttributes(const Decl *D,
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000624 llvm::GlobalValue *GV) {
Anders Carlsson934176f2011-01-29 19:41:00 +0000625 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
626 setGlobalVisibility(GV, ND);
John McCall1fb0caa2010-10-22 21:05:15 +0000627 else
628 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000629
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000630 if (D->hasAttr<UsedAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000631 AddUsedGlobal(GV);
632
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000633 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000634 GV->setSection(SA->getName());
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000635
636 getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000637}
638
Daniel Dunbar0e4f40e2009-04-17 00:48:04 +0000639void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
640 llvm::Function *F,
641 const CGFunctionInfo &FI) {
642 SetLLVMFunctionAttributes(D, FI, F);
643 SetLLVMFunctionAttributesForDefinition(D, F);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000644
645 F->setLinkage(llvm::Function::InternalLinkage);
646
Daniel Dunbar0e4f40e2009-04-17 00:48:04 +0000647 SetCommonAttributes(D, F);
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000648}
649
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000650void CodeGenModule::SetFunctionAttributes(GlobalDecl GD,
Eli Friedmanc6c14d12009-05-26 01:22:57 +0000651 llvm::Function *F,
652 bool IsIncompleteFunction) {
Peter Collingbourne0ac2cf42011-04-06 12:29:04 +0000653 if (unsigned IID = F->getIntrinsicID()) {
654 // If this is an intrinsic function, set the function's attributes
655 // to the intrinsic's attributes.
Bill Wendling50e6b182012-10-15 04:47:45 +0000656 F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(),
657 (llvm::Intrinsic::ID)IID));
Peter Collingbourne0ac2cf42011-04-06 12:29:04 +0000658 return;
659 }
660
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000661 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
662
Eli Friedmanc6c14d12009-05-26 01:22:57 +0000663 if (!IsIncompleteFunction)
John McCallde5d3c72012-02-17 03:33:10 +0000664 SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F);
Mike Stump1eb44332009-09-09 15:08:12 +0000665
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000666 // Only a few attributes are set on declarations; these may later be
667 // overridden by a definition.
Mike Stump1eb44332009-09-09 15:08:12 +0000668
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000669 if (FD->hasAttr<DLLImportAttr>()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000670 F->setLinkage(llvm::Function::DLLImportLinkage);
Mike Stump1eb44332009-09-09 15:08:12 +0000671 } else if (FD->hasAttr<WeakAttr>() ||
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000672 FD->isWeakImported()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000673 // "extern_weak" is overloaded in LLVM; we probably should have
Mike Stump1eb44332009-09-09 15:08:12 +0000674 // separate linkage types for this.
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000675 F->setLinkage(llvm::Function::ExternalWeakLinkage);
676 } else {
Mike Stump1eb44332009-09-09 15:08:12 +0000677 F->setLinkage(llvm::Function::ExternalLinkage);
John McCallaf146032010-10-30 11:50:40 +0000678
679 NamedDecl::LinkageInfo LV = FD->getLinkageAndVisibility();
680 if (LV.linkage() == ExternalLinkage && LV.visibilityExplicit()) {
681 F->setVisibility(GetLLVMVisibility(LV.visibility()));
682 }
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000683 }
684
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000685 if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000686 F->setSection(SA->getName());
Daniel Dunbar219df662008-09-08 23:44:31 +0000687}
688
Daniel Dunbar02698712009-02-13 20:29:50 +0000689void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
Mike Stump1eb44332009-09-09 15:08:12 +0000690 assert(!GV->isDeclaration() &&
Daniel Dunbar02698712009-02-13 20:29:50 +0000691 "Only globals with definition can force usage.");
Chris Lattner35f38a22009-03-31 22:37:52 +0000692 LLVMUsed.push_back(GV);
Daniel Dunbar02698712009-02-13 20:29:50 +0000693}
694
695void CodeGenModule::EmitLLVMUsed() {
696 // Don't create llvm.used if there is no need.
Chris Lattnerad64e022009-07-17 23:57:13 +0000697 if (LLVMUsed.empty())
Daniel Dunbar02698712009-02-13 20:29:50 +0000698 return;
699
Chris Lattner35f38a22009-03-31 22:37:52 +0000700 // Convert LLVMUsed to what ConstantArray needs.
Chris Lattner0b239712012-02-06 22:16:34 +0000701 SmallVector<llvm::Constant*, 8> UsedArray;
Chris Lattner35f38a22009-03-31 22:37:52 +0000702 UsedArray.resize(LLVMUsed.size());
703 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
Mike Stump1eb44332009-09-09 15:08:12 +0000704 UsedArray[i] =
705 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
Chris Lattner0b239712012-02-06 22:16:34 +0000706 Int8PtrTy);
Chris Lattner35f38a22009-03-31 22:37:52 +0000707 }
Mike Stump1eb44332009-09-09 15:08:12 +0000708
Fariborz Jahanianc38e9af2009-06-23 21:47:46 +0000709 if (UsedArray.empty())
710 return;
Chris Lattner0b239712012-02-06 22:16:34 +0000711 llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size());
Mike Stump1eb44332009-09-09 15:08:12 +0000712
713 llvm::GlobalVariable *GV =
714 new llvm::GlobalVariable(getModule(), ATy, false,
Daniel Dunbar02698712009-02-13 20:29:50 +0000715 llvm::GlobalValue::AppendingLinkage,
Owen Anderson7db6d832009-07-28 18:33:04 +0000716 llvm::ConstantArray::get(ATy, UsedArray),
Owen Anderson1c431b32009-07-08 19:05:04 +0000717 "llvm.used");
Daniel Dunbar02698712009-02-13 20:29:50 +0000718
719 GV->setSection("llvm.metadata");
720}
721
Douglas Gregor858afb32013-01-14 20:53:57 +0000722/// \brief Add link options implied by the given module, including modules
723/// it depends on, using a postorder walk.
724static void addLinkOptionsPostorder(llvm::LLVMContext &Context,
725 Module *Mod,
726 SmallVectorImpl<llvm::MDNode *> &Metadata,
727 llvm::SmallPtrSet<Module *, 16> &Visited) {
728 // Import this module's parent.
729 if (Mod->Parent && Visited.insert(Mod->Parent)) {
730 addLinkOptionsPostorder(Context, Mod->Parent, Metadata, Visited);
731 }
732
733 // Import this module's dependencies.
734 for (unsigned I = Mod->Imports.size(); I > 0; --I) {
735 if (Visited.insert(Mod->Imports[I-1]))
736 addLinkOptionsPostorder(Context, Mod->Imports[I-1], Metadata, Visited);
737 }
738
739 // Add linker options to link against the libraries/frameworks
740 // described by this module.
741 for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) {
742 // FIXME: -lfoo is Unix-centric and -framework Foo is Darwin-centric.
743 // We need to know more about the linker to know how to encode these
744 // options propertly.
745
746 // Link against a framework.
747 if (Mod->LinkLibraries[I-1].IsFramework) {
748 llvm::Value *Args[2] = {
749 llvm::MDString::get(Context, "-framework"),
750 llvm::MDString::get(Context, Mod->LinkLibraries[I-1].Library)
751 };
752
753 Metadata.push_back(llvm::MDNode::get(Context, Args));
754 continue;
755 }
756
757 // Link against a library.
758 llvm::Value *OptString
759 = llvm::MDString::get(Context,
760 "-l" + Mod->LinkLibraries[I-1].Library);
761 Metadata.push_back(llvm::MDNode::get(Context, OptString));
762 }
763}
764
765void CodeGenModule::EmitModuleLinkOptions() {
766 // Collect the set of all of the modules we want to visit to emit link
767 // options, which is essentially the imported modules and all of their
768 // non-explicit child modules.
769 llvm::SetVector<clang::Module *> LinkModules;
770 llvm::SmallPtrSet<clang::Module *, 16> Visited;
771 SmallVector<clang::Module *, 16> Stack;
772
773 // Seed the stack with imported modules.
774 for (llvm::SetVector<clang::Module *>::iterator M = ImportedModules.begin(),
775 MEnd = ImportedModules.end();
776 M != MEnd; ++M) {
777 if (Visited.insert(*M))
778 Stack.push_back(*M);
779 }
780
781 // Find all of the modules to import, making a little effort to prune
782 // non-leaf modules.
783 while (!Stack.empty()) {
784 clang::Module *Mod = Stack.back();
785 Stack.pop_back();
786
787 bool AnyChildren = false;
788
789 // Visit the submodules of this module.
790 for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(),
791 SubEnd = Mod->submodule_end();
792 Sub != SubEnd; ++Sub) {
793 // Skip explicit children; they need to be explicitly imported to be
794 // linked against.
795 if ((*Sub)->IsExplicit)
796 continue;
797
798 if (Visited.insert(*Sub)) {
799 Stack.push_back(*Sub);
800 AnyChildren = true;
801 }
802 }
803
804 // We didn't find any children, so add this module to the list of
805 // modules to link against.
806 if (!AnyChildren) {
807 LinkModules.insert(Mod);
808 }
809 }
810
811 // Add link options for all of the imported modules in reverse topological
812 // order.
813 SmallVector<llvm::MDNode *, 16> MetadataArgs;
814 Visited.clear();
815 for (llvm::SetVector<clang::Module *>::iterator M = LinkModules.begin(),
816 MEnd = LinkModules.end();
817 M != MEnd; ++M) {
818 if (Visited.insert(*M))
819 addLinkOptionsPostorder(getLLVMContext(), *M, MetadataArgs, Visited);
820 }
821
822 // Get/create metadata for the link options.
823 llvm::NamedMDNode *Metadata
824 = getModule().getOrInsertNamedMetadata("llvm.module.linkoptions");
825
826 // Add link options in topological order.
827 for (unsigned I = MetadataArgs.size(); I > 0; --I) {
828 Metadata->addOperand(MetadataArgs[I-1]);
829 }
830}
831
Daniel Dunbar02698712009-02-13 20:29:50 +0000832void CodeGenModule::EmitDeferred() {
Chris Lattner67b00522009-03-21 09:44:56 +0000833 // Emit code for any potentially referenced deferred decls. Since a
834 // previously unused static decl may become used during the generation of code
Nick Lewyckydce67a72011-07-18 05:26:13 +0000835 // for a static function, iterate until no changes are made.
Rafael Espindolabbf58bb2010-03-10 02:19:29 +0000836
Anders Carlsson046c2942010-04-17 20:15:18 +0000837 while (!DeferredDeclsToEmit.empty() || !DeferredVTables.empty()) {
838 if (!DeferredVTables.empty()) {
839 const CXXRecordDecl *RD = DeferredVTables.back();
840 DeferredVTables.pop_back();
Charles Davis9ee494f2012-06-23 23:44:00 +0000841 getCXXABI().EmitVTables(RD);
Rafael Espindolabbf58bb2010-03-10 02:19:29 +0000842 continue;
843 }
844
Anders Carlsson2a131fb2009-05-05 04:44:02 +0000845 GlobalDecl D = DeferredDeclsToEmit.back();
Chris Lattner67b00522009-03-21 09:44:56 +0000846 DeferredDeclsToEmit.pop_back();
847
John McCallc76702c2010-05-27 01:45:30 +0000848 // Check to see if we've already emitted this. This is necessary
849 // for a couple of reasons: first, decls can end up in the
850 // deferred-decls queue multiple times, and second, decls can end
851 // up with definitions in unusual ways (e.g. by an extern inline
852 // function acquiring a strong function redefinition). Just
853 // ignore these cases.
854 //
855 // TODO: That said, looking this up multiple times is very wasteful.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000856 StringRef Name = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +0000857 llvm::GlobalValue *CGRef = GetGlobalValue(Name);
Chris Lattner67b00522009-03-21 09:44:56 +0000858 assert(CGRef && "Deferred decl wasn't referenced?");
Mike Stump1eb44332009-09-09 15:08:12 +0000859
Chris Lattner67b00522009-03-21 09:44:56 +0000860 if (!CGRef->isDeclaration())
861 continue;
Mike Stump1eb44332009-09-09 15:08:12 +0000862
John McCallc76702c2010-05-27 01:45:30 +0000863 // GlobalAlias::isDeclaration() defers to the aliasee, but for our
864 // purposes an alias counts as a definition.
865 if (isa<llvm::GlobalAlias>(CGRef))
866 continue;
867
Chris Lattner67b00522009-03-21 09:44:56 +0000868 // Otherwise, emit the definition and move on to the next one.
869 EmitGlobalDefinition(D);
870 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000871}
872
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000873void CodeGenModule::EmitGlobalAnnotations() {
874 if (Annotations.empty())
875 return;
876
877 // Create a new global variable for the ConstantStruct in the Module.
878 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
879 Annotations[0]->getType(), Annotations.size()), Annotations);
880 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(),
881 Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array,
882 "llvm.global.annotations");
883 gv->setSection(AnnotationSection);
884}
885
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +0000886llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000887 llvm::StringMap<llvm::Constant*>::iterator i = AnnotationStrings.find(Str);
888 if (i != AnnotationStrings.end())
889 return i->second;
890
891 // Not found yet, create a new global.
Chris Lattner94010692012-02-05 02:30:40 +0000892 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000893 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(),
894 true, llvm::GlobalValue::PrivateLinkage, s, ".str");
895 gv->setSection(AnnotationSection);
896 gv->setUnnamedAddr(true);
897 AnnotationStrings[Str] = gv;
898 return gv;
899}
900
901llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) {
902 SourceManager &SM = getContext().getSourceManager();
903 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
904 if (PLoc.isValid())
905 return EmitAnnotationString(PLoc.getFilename());
906 return EmitAnnotationString(SM.getBufferName(Loc));
907}
908
909llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
910 SourceManager &SM = getContext().getSourceManager();
911 PresumedLoc PLoc = SM.getPresumedLoc(L);
912 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
913 SM.getExpansionLineNumber(L);
914 return llvm::ConstantInt::get(Int32Ty, LineNo);
915}
916
Mike Stump1eb44332009-09-09 15:08:12 +0000917llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000918 const AnnotateAttr *AA,
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000919 SourceLocation L) {
920 // Get the globals for file name, annotation, and the line number.
921 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
922 *UnitGV = EmitAnnotationUnit(L),
923 *LineNoCst = EmitAnnotationLineNo(L);
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000924
Daniel Dunbar57d5cee2009-04-14 22:41:13 +0000925 // Create the ConstantStruct for the global annotation.
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000926 llvm::Constant *Fields[4] = {
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000927 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
928 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
929 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
930 LineNoCst
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000931 };
Chris Lattnerc5cbb902011-06-20 04:01:35 +0000932 return llvm::ConstantStruct::getAnon(Fields);
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000933}
934
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000935void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
936 llvm::GlobalValue *GV) {
937 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
938 // Get the struct elements for these annotations.
939 for (specific_attr_iterator<AnnotateAttr>
940 ai = D->specific_attr_begin<AnnotateAttr>(),
941 ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai)
942 Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation()));
943}
944
Argyrios Kyrtzidisa6d6af32010-07-27 22:37:14 +0000945bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
Argyrios Kyrtzidis90e99a82010-07-29 18:15:58 +0000946 // Never defer when EmitAllDecls is specified.
David Blaikie4e4d0842012-03-11 07:00:24 +0000947 if (LangOpts.EmitAllDecls)
Daniel Dunbar73241df2009-02-13 21:18:01 +0000948 return false;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000949
Argyrios Kyrtzidis4ac7c0b2010-07-29 20:08:05 +0000950 return !getContext().DeclMustBeEmitted(Global);
Daniel Dunbar73241df2009-02-13 21:18:01 +0000951}
952
Nico Weberc5f80462012-10-11 10:13:44 +0000953llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor(
954 const CXXUuidofExpr* E) {
955 // Sema has verified that IIDSource has a __declspec(uuid()), and that its
956 // well-formed.
957 StringRef Uuid;
958 if (E->isTypeOperand())
959 Uuid = CXXUuidofExpr::GetUuidAttrOfType(E->getTypeOperand())->getGuid();
960 else {
961 // Special case: __uuidof(0) means an all-zero GUID.
962 Expr *Op = E->getExprOperand();
963 if (!Op->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
964 Uuid = CXXUuidofExpr::GetUuidAttrOfType(Op->getType())->getGuid();
965 else
966 Uuid = "00000000-0000-0000-0000-000000000000";
967 }
968 std::string Name = "__uuid_" + Uuid.str();
969
970 // Look for an existing global.
971 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
972 return GV;
973
974 llvm::Constant *Init = EmitUuidofInitializer(Uuid, E->getType());
975 assert(Init && "failed to initialize as constant");
976
977 // GUIDs are assumed to be 16 bytes, spread over 4-2-2-8 bytes. However, the
978 // first field is declared as "long", which for many targets is 8 bytes.
979 // Those architectures are not supported. (With the MS abi, long is always 4
980 // bytes.)
981 llvm::Type *GuidType = getTypes().ConvertType(E->getType());
982 if (Init->getType() != GuidType) {
983 DiagnosticsEngine &Diags = getDiags();
984 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
985 "__uuidof codegen is not supported on this architecture");
986 Diags.Report(E->getExprLoc(), DiagID) << E->getSourceRange();
987 Init = llvm::UndefValue::get(GuidType);
988 }
989
990 llvm::GlobalVariable *GV = new llvm::GlobalVariable(getModule(), GuidType,
991 /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, Init, Name);
992 GV->setUnnamedAddr(true);
993 return GV;
994}
995
Rafael Espindola6a836702010-03-04 18:17:24 +0000996llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
997 const AliasAttr *AA = VD->getAttr<AliasAttr>();
998 assert(AA && "No alias?");
999
Chris Lattner2acc6e32011-07-18 04:24:23 +00001000 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
Rafael Espindola6a836702010-03-04 18:17:24 +00001001
Rafael Espindola6a836702010-03-04 18:17:24 +00001002 // See if there is already something with the target's name in the module.
John McCallf746aa62010-03-19 23:29:14 +00001003 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
Joerg Sonnenberger4695f912012-10-16 17:45:27 +00001004 if (Entry) {
1005 unsigned AS = getContext().getTargetAddressSpace(VD->getType());
1006 return llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
1007 }
Rafael Espindola6a836702010-03-04 18:17:24 +00001008
1009 llvm::Constant *Aliasee;
1010 if (isa<llvm::FunctionType>(DeclTy))
Alex Rosenbergc857ce82012-10-05 23:12:53 +00001011 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
1012 GlobalDecl(cast<FunctionDecl>(VD)),
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001013 /*ForVTable=*/false);
Rafael Espindola6a836702010-03-04 18:17:24 +00001014 else
John McCallf746aa62010-03-19 23:29:14 +00001015 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Rafael Espindola6a836702010-03-04 18:17:24 +00001016 llvm::PointerType::getUnqual(DeclTy), 0);
Joerg Sonnenberger4695f912012-10-16 17:45:27 +00001017
1018 llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee);
1019 F->setLinkage(llvm::Function::ExternalWeakLinkage);
1020 WeakRefReferences.insert(F);
Rafael Espindola6a836702010-03-04 18:17:24 +00001021
1022 return Aliasee;
1023}
1024
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001025void CodeGenModule::EmitGlobal(GlobalDecl GD) {
Anders Carlsson4a6835e2009-09-10 23:38:47 +00001026 const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00001027
Rafael Espindola6a836702010-03-04 18:17:24 +00001028 // Weak references don't produce any output by themselves.
1029 if (Global->hasAttr<WeakRefAttr>())
1030 return;
1031
Chris Lattnerbd532712009-03-22 21:47:11 +00001032 // If this is an alias definition (which otherwise looks like a declaration)
1033 // emit it now.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001034 if (Global->hasAttr<AliasAttr>())
John McCallf746aa62010-03-19 23:29:14 +00001035 return EmitAliasDefinition(GD);
Daniel Dunbar219df662008-09-08 23:44:31 +00001036
Peter Collingbourned51e43a2011-10-06 18:29:46 +00001037 // If this is CUDA, be selective about which declarations we emit.
David Blaikie4e4d0842012-03-11 07:00:24 +00001038 if (LangOpts.CUDA) {
Peter Collingbourned51e43a2011-10-06 18:29:46 +00001039 if (CodeGenOpts.CUDAIsDevice) {
1040 if (!Global->hasAttr<CUDADeviceAttr>() &&
1041 !Global->hasAttr<CUDAGlobalAttr>() &&
1042 !Global->hasAttr<CUDAConstantAttr>() &&
1043 !Global->hasAttr<CUDASharedAttr>())
1044 return;
1045 } else {
1046 if (!Global->hasAttr<CUDAHostAttr>() && (
1047 Global->hasAttr<CUDADeviceAttr>() ||
1048 Global->hasAttr<CUDAConstantAttr>() ||
1049 Global->hasAttr<CUDASharedAttr>()))
1050 return;
1051 }
1052 }
1053
Chris Lattner67b00522009-03-21 09:44:56 +00001054 // Ignore declarations, they will be emitted on their first use.
Daniel Dunbar5e1e1f92009-03-19 08:27:24 +00001055 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
Daniel Dunbar73241df2009-02-13 21:18:01 +00001056 // Forward declarations are emitted lazily on first use.
Nick Lewyckydce67a72011-07-18 05:26:13 +00001057 if (!FD->doesThisDeclarationHaveABody()) {
1058 if (!FD->doesDeclarationForceExternallyVisibleDefinition())
1059 return;
1060
1061 const FunctionDecl *InlineDefinition = 0;
1062 FD->getBody(InlineDefinition);
1063
Chris Lattner5f9e2722011-07-23 10:55:15 +00001064 StringRef MangledName = getMangledName(GD);
Benjamin Kramer7e423922012-03-24 18:22:12 +00001065 DeferredDecls.erase(MangledName);
Nick Lewyckydce67a72011-07-18 05:26:13 +00001066 EmitGlobalDefinition(InlineDefinition);
Daniel Dunbar73241df2009-02-13 21:18:01 +00001067 return;
Nick Lewyckydce67a72011-07-18 05:26:13 +00001068 }
Daniel Dunbar02698712009-02-13 20:29:50 +00001069 } else {
1070 const VarDecl *VD = cast<VarDecl>(Global);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001071 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
1072
Douglas Gregora9a55c02010-02-06 05:15:45 +00001073 if (VD->isThisDeclarationADefinition() != VarDecl::Definition)
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +00001074 return;
Nate Begeman4c13b7a2008-04-20 06:29:50 +00001075 }
1076
Chris Lattner67b00522009-03-21 09:44:56 +00001077 // Defer code generation when possible if this is a static definition, inline
1078 // function etc. These we only want to emit if they are used.
Chris Lattner4357a822010-04-13 17:39:09 +00001079 if (!MayDeferGeneration(Global)) {
1080 // Emit the definition if it can't be deferred.
1081 EmitGlobalDefinition(GD);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001082 return;
1083 }
John McCallbf40cb52010-07-15 23:40:35 +00001084
1085 // If we're deferring emission of a C++ variable with an
1086 // initializer, remember the order in which it appeared in the file.
David Blaikie4e4d0842012-03-11 07:00:24 +00001087 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
John McCallbf40cb52010-07-15 23:40:35 +00001088 cast<VarDecl>(Global)->hasInit()) {
1089 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
1090 CXXGlobalInits.push_back(0);
1091 }
Chris Lattner4357a822010-04-13 17:39:09 +00001092
1093 // If the value has already been used, add it directly to the
1094 // DeferredDeclsToEmit list.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001095 StringRef MangledName = getMangledName(GD);
Chris Lattner4357a822010-04-13 17:39:09 +00001096 if (GetGlobalValue(MangledName))
1097 DeferredDeclsToEmit.push_back(GD);
1098 else {
1099 // Otherwise, remember that we saw a deferred decl with this name. The
1100 // first use of the mangled name will cause it to move into
1101 // DeferredDeclsToEmit.
1102 DeferredDecls[MangledName] = GD;
1103 }
Nate Begeman4c13b7a2008-04-20 06:29:50 +00001104}
1105
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001106namespace {
1107 struct FunctionIsDirectlyRecursive :
1108 public RecursiveASTVisitor<FunctionIsDirectlyRecursive> {
1109 const StringRef Name;
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001110 const Builtin::Context &BI;
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001111 bool Result;
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001112 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) :
1113 Name(N), BI(C), Result(false) {
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001114 }
1115 typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base;
1116
1117 bool TraverseCallExpr(CallExpr *E) {
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001118 const FunctionDecl *FD = E->getDirectCallee();
1119 if (!FD)
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001120 return true;
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001121 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1122 if (Attr && Name == Attr->getLabel()) {
1123 Result = true;
1124 return false;
1125 }
1126 unsigned BuiltinID = FD->getBuiltinID();
1127 if (!BuiltinID)
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001128 return true;
Nick Lewyckyf6b56372012-01-18 03:41:19 +00001129 StringRef BuiltinName = BI.GetName(BuiltinID);
1130 if (BuiltinName.startswith("__builtin_") &&
1131 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001132 Result = true;
1133 return false;
1134 }
1135 return true;
1136 }
1137 };
1138}
1139
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001140// isTriviallyRecursive - Check if this function calls another
1141// decl that, because of the asm attribute or the other decl being a builtin,
1142// ends up pointing to itself.
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001143bool
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001144CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
1145 StringRef Name;
1146 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
Nick Lewycky22afacc2012-01-18 01:50:13 +00001147 // asm labels are a special kind of mangling we have to support.
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001148 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1149 if (!Attr)
1150 return false;
1151 Name = Attr->getLabel();
1152 } else {
1153 Name = FD->getName();
1154 }
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001155
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001156 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
1157 Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD));
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001158 return Walker.Result;
1159}
1160
1161bool
1162CodeGenModule::shouldEmitFunction(const FunctionDecl *F) {
1163 if (getFunctionLinkage(F) != llvm::Function::AvailableExternallyLinkage)
1164 return true;
Rafael Espindolacc4889f2011-10-28 20:43:56 +00001165 if (CodeGenOpts.OptimizationLevel == 0 &&
Michael J. Spenceradc6cbf2012-06-18 07:00:48 +00001166 !F->hasAttr<AlwaysInlineAttr>() && !F->hasAttr<ForceInlineAttr>())
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001167 return false;
1168 // PR9614. Avoid cases where the source code is lying to us. An available
1169 // externally function should have an equivalent function somewhere else,
1170 // but a function that calls itself is clearly not equivalent to the real
1171 // implementation.
1172 // This happens in glibc's btowc and in some configure checks.
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001173 return !isTriviallyRecursive(F);
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001174}
1175
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001176void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
Anders Carlsson4a6835e2009-09-10 23:38:47 +00001177 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00001178
Dan Gohmancb421fa2010-04-19 16:39:44 +00001179 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
Anders Carlsson8e2efcc2009-10-27 14:32:27 +00001180 Context.getSourceManager(),
1181 "Generating code for declaration");
1182
Douglas Gregor44eac332010-07-13 06:02:28 +00001183 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
1184 // At -O0, don't generate IR for functions with available_externally
1185 // linkage.
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001186 if (!shouldEmitFunction(Function))
Douglas Gregor44eac332010-07-13 06:02:28 +00001187 return;
Anders Carlsson7270ee42010-03-23 04:31:31 +00001188
Douglas Gregor44eac332010-07-13 06:02:28 +00001189 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
Eli Friedman7dcdf5b2011-05-06 17:27:27 +00001190 // Make sure to emit the definition(s) before we emit the thunks.
1191 // This is necessary for the generation of certain thunks.
1192 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
1193 EmitCXXConstructor(CD, GD.getCtorType());
1194 else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method))
1195 EmitCXXDestructor(DD, GD.getDtorType());
1196 else
1197 EmitGlobalFunctionDefinition(GD);
1198
Douglas Gregor44eac332010-07-13 06:02:28 +00001199 if (Method->isVirtual())
1200 getVTables().EmitThunks(GD);
1201
Eli Friedman7dcdf5b2011-05-06 17:27:27 +00001202 return;
Douglas Gregor44eac332010-07-13 06:02:28 +00001203 }
Chris Lattnerb5e81562010-04-13 17:57:11 +00001204
Chris Lattnerb5e81562010-04-13 17:57:11 +00001205 return EmitGlobalFunctionDefinition(GD);
Douglas Gregor44eac332010-07-13 06:02:28 +00001206 }
Chris Lattnerb5e81562010-04-13 17:57:11 +00001207
1208 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
1209 return EmitGlobalVarDefinition(VD);
Chris Lattner4357a822010-04-13 17:39:09 +00001210
David Blaikieb219cfc2011-09-23 05:06:16 +00001211 llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001212}
1213
Chris Lattner74391b42009-03-22 21:03:39 +00001214/// GetOrCreateLLVMFunction - If the specified mangled name is not in the
1215/// module, create and return an llvm Function with the specified type. If there
1216/// is something in the module with the specified name, return it potentially
1217/// bitcasted to the right type.
1218///
1219/// If D is non-null, it specifies a decl that correspond to this. This is used
1220/// to set the attributes on the function when it is first created.
John McCallf746aa62010-03-19 23:29:14 +00001221llvm::Constant *
Chris Lattner5f9e2722011-07-23 10:55:15 +00001222CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001223 llvm::Type *Ty,
John McCallf85e1932011-06-15 23:02:42 +00001224 GlobalDecl D, bool ForVTable,
Bill Wendling72390b32012-12-20 19:27:06 +00001225 llvm::Attribute ExtraAttrs) {
Chris Lattner0558e792009-03-21 09:25:43 +00001226 // Lookup the entry, lazily creating it if necessary.
John McCallf746aa62010-03-19 23:29:14 +00001227 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner0558e792009-03-21 09:25:43 +00001228 if (Entry) {
Benjamin Kramerd48bcb22012-08-22 15:37:55 +00001229 if (WeakRefReferences.erase(Entry)) {
Rafael Espindola6a836702010-03-04 18:17:24 +00001230 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl());
1231 if (FD && !FD->hasAttr<WeakAttr>())
Anders Carlsson7270ee42010-03-23 04:31:31 +00001232 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola6a836702010-03-04 18:17:24 +00001233 }
1234
Chris Lattner0558e792009-03-21 09:25:43 +00001235 if (Entry->getType()->getElementType() == Ty)
1236 return Entry;
Mike Stump1eb44332009-09-09 15:08:12 +00001237
Chris Lattner0558e792009-03-21 09:25:43 +00001238 // Make sure the result is of the correct type.
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001239 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
Chris Lattner0558e792009-03-21 09:25:43 +00001240 }
Mike Stump1eb44332009-09-09 15:08:12 +00001241
Eli Friedman654ad402009-11-09 05:07:37 +00001242 // This function doesn't have a complete type (for example, the return
1243 // type is an incomplete struct). Use a fake type instead, and make
1244 // sure not to try to set attributes.
1245 bool IsIncompleteFunction = false;
John McCall784f2112010-04-28 00:00:30 +00001246
Chris Lattner2acc6e32011-07-18 04:24:23 +00001247 llvm::FunctionType *FTy;
John McCall784f2112010-04-28 00:00:30 +00001248 if (isa<llvm::FunctionType>(Ty)) {
1249 FTy = cast<llvm::FunctionType>(Ty);
1250 } else {
John McCall0774cb82011-05-15 01:53:33 +00001251 FTy = llvm::FunctionType::get(VoidTy, false);
Eli Friedman654ad402009-11-09 05:07:37 +00001252 IsIncompleteFunction = true;
1253 }
Chris Lattnerbcaedae2010-06-30 19:14:05 +00001254
John McCall784f2112010-04-28 00:00:30 +00001255 llvm::Function *F = llvm::Function::Create(FTy,
Eli Friedman654ad402009-11-09 05:07:37 +00001256 llvm::Function::ExternalLinkage,
John McCallf746aa62010-03-19 23:29:14 +00001257 MangledName, &getModule());
1258 assert(F->getName() == MangledName && "name was uniqued!");
Eli Friedman654ad402009-11-09 05:07:37 +00001259 if (D.getDecl())
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +00001260 SetFunctionAttributes(D, F, IsIncompleteFunction);
Bill Wendlingfac63102012-10-10 03:13:20 +00001261 if (ExtraAttrs.hasAttributes())
Bill Wendling785b7782012-12-07 23:17:26 +00001262 F->addAttribute(llvm::AttributeSet::FunctionIndex, ExtraAttrs);
Eli Friedman654ad402009-11-09 05:07:37 +00001263
Chris Lattner67b00522009-03-21 09:44:56 +00001264 // This is the first use or definition of a mangled name. If there is a
1265 // deferred decl with this name, remember that we need to emit it at the end
1266 // of the file.
John McCallf746aa62010-03-19 23:29:14 +00001267 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner67b00522009-03-21 09:44:56 +00001268 if (DDI != DeferredDecls.end()) {
1269 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1270 // list, and remove it from DeferredDecls (since we don't need it anymore).
1271 DeferredDeclsToEmit.push_back(DDI->second);
1272 DeferredDecls.erase(DDI);
John McCallbfdcdc82010-12-15 04:00:32 +00001273
1274 // Otherwise, there are cases we have to worry about where we're
1275 // using a declaration for which we must emit a definition but where
1276 // we might not find a top-level definition:
1277 // - member functions defined inline in their classes
1278 // - friend functions defined inline in some class
1279 // - special member functions with implicit definitions
1280 // If we ever change our AST traversal to walk into class methods,
1281 // this will be unnecessary.
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001282 //
1283 // We also don't emit a definition for a function if it's going to be an entry
1284 // in a vtable, unless it's already marked as used.
David Blaikie4e4d0842012-03-11 07:00:24 +00001285 } else if (getLangOpts().CPlusPlus && D.getDecl()) {
John McCallbfdcdc82010-12-15 04:00:32 +00001286 // Look for a declaration that's lexically in a record.
1287 const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl());
Eli Friedmanb135f0f2012-07-02 21:05:30 +00001288 FD = FD->getMostRecentDecl();
John McCallbfdcdc82010-12-15 04:00:32 +00001289 do {
1290 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001291 if (FD->isImplicit() && !ForVTable) {
John McCallbfdcdc82010-12-15 04:00:32 +00001292 assert(FD->isUsed() && "Sema didn't mark implicit function as used!");
Douglas Gregora29bf412011-02-09 02:03:05 +00001293 DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
John McCallbfdcdc82010-12-15 04:00:32 +00001294 break;
Sean Hunt10620eb2011-05-06 20:44:56 +00001295 } else if (FD->doesThisDeclarationHaveABody()) {
Douglas Gregora29bf412011-02-09 02:03:05 +00001296 DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
John McCallbfdcdc82010-12-15 04:00:32 +00001297 break;
1298 }
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +00001299 }
Douglas Gregoref96ee02012-01-14 16:38:05 +00001300 FD = FD->getPreviousDecl();
John McCallbfdcdc82010-12-15 04:00:32 +00001301 } while (FD);
Chris Lattner67b00522009-03-21 09:44:56 +00001302 }
Mike Stump1eb44332009-09-09 15:08:12 +00001303
John McCall784f2112010-04-28 00:00:30 +00001304 // Make sure the result is of the requested type.
1305 if (!IsIncompleteFunction) {
1306 assert(F->getType()->getElementType() == Ty);
1307 return F;
1308 }
1309
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001310 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
John McCall784f2112010-04-28 00:00:30 +00001311 return llvm::ConstantExpr::getBitCast(F, PTy);
Chris Lattner0558e792009-03-21 09:25:43 +00001312}
1313
Chris Lattner74391b42009-03-22 21:03:39 +00001314/// GetAddrOfFunction - Return the address of the given function. If Ty is
1315/// non-null, then this function will use the specified type if it has to
1316/// create it (this occurs when we see a definition of the function).
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001317llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001318 llvm::Type *Ty,
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001319 bool ForVTable) {
Chris Lattner74391b42009-03-22 21:03:39 +00001320 // If there was no specific requested type, just convert it now.
1321 if (!Ty)
Anders Carlsson4a6835e2009-09-10 23:38:47 +00001322 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
Chris Lattnerbcaedae2010-06-30 19:14:05 +00001323
Chris Lattner5f9e2722011-07-23 10:55:15 +00001324 StringRef MangledName = getMangledName(GD);
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001325 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable);
Chris Lattner74391b42009-03-22 21:03:39 +00001326}
Eli Friedman77ba7082008-05-30 19:50:47 +00001327
Chris Lattner74391b42009-03-22 21:03:39 +00001328/// CreateRuntimeFunction - Create a new runtime function with the specified
1329/// type and name.
1330llvm::Constant *
Chris Lattner2acc6e32011-07-18 04:24:23 +00001331CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001332 StringRef Name,
Bill Wendling72390b32012-12-20 19:27:06 +00001333 llvm::Attribute ExtraAttrs) {
John McCallf85e1932011-06-15 23:02:42 +00001334 return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
1335 ExtraAttrs);
Chris Lattner74391b42009-03-22 21:03:39 +00001336}
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001337
Richard Smitha9b21d22012-02-17 06:48:11 +00001338/// isTypeConstant - Determine whether an object of this type can be emitted
1339/// as a constant.
1340///
1341/// If ExcludeCtor is true, the duration when the object's constructor runs
1342/// will not be considered. The caller will need to verify that the object is
1343/// not written to during its construction.
1344bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
1345 if (!Ty.isConstant(Context) && !Ty->isReferenceType())
Eli Friedman20e098b2009-12-11 21:23:03 +00001346 return false;
Richard Smitha9b21d22012-02-17 06:48:11 +00001347
David Blaikie4e4d0842012-03-11 07:00:24 +00001348 if (Context.getLangOpts().CPlusPlus) {
Richard Smitha9b21d22012-02-17 06:48:11 +00001349 if (const CXXRecordDecl *Record
1350 = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
1351 return ExcludeCtor && !Record->hasMutableFields() &&
1352 Record->hasTrivialDestructor();
Eli Friedman20e098b2009-12-11 21:23:03 +00001353 }
Richard Smitha9b21d22012-02-17 06:48:11 +00001354
Eli Friedman20e098b2009-12-11 21:23:03 +00001355 return true;
1356}
1357
Chris Lattner74391b42009-03-22 21:03:39 +00001358/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
1359/// create and return an llvm GlobalVariable with the specified type. If there
1360/// is something in the module with the specified name, return it potentially
1361/// bitcasted to the right type.
1362///
1363/// If D is non-null, it specifies a decl that correspond to this. This is used
1364/// to set the attributes on the global when it is first created.
John McCallf746aa62010-03-19 23:29:14 +00001365llvm::Constant *
Chris Lattner5f9e2722011-07-23 10:55:15 +00001366CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001367 llvm::PointerType *Ty,
Rafael Espindolac532b502011-01-18 21:07:57 +00001368 const VarDecl *D,
1369 bool UnnamedAddr) {
Daniel Dunbar3c827a72008-08-05 23:31:02 +00001370 // Lookup the entry, lazily creating it if necessary.
John McCallf746aa62010-03-19 23:29:14 +00001371 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner99b53612009-03-21 08:03:33 +00001372 if (Entry) {
Benjamin Kramerd48bcb22012-08-22 15:37:55 +00001373 if (WeakRefReferences.erase(Entry)) {
Rafael Espindola6a836702010-03-04 18:17:24 +00001374 if (D && !D->hasAttr<WeakAttr>())
Anders Carlsson7270ee42010-03-23 04:31:31 +00001375 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola6a836702010-03-04 18:17:24 +00001376 }
1377
Rafael Espindolac532b502011-01-18 21:07:57 +00001378 if (UnnamedAddr)
1379 Entry->setUnnamedAddr(true);
1380
Chris Lattner74391b42009-03-22 21:03:39 +00001381 if (Entry->getType() == Ty)
Chris Lattner570585c2009-03-21 09:16:30 +00001382 return Entry;
Mike Stump1eb44332009-09-09 15:08:12 +00001383
Chris Lattner99b53612009-03-21 08:03:33 +00001384 // Make sure the result is of the correct type.
Owen Anderson3c4972d2009-07-29 18:54:39 +00001385 return llvm::ConstantExpr::getBitCast(Entry, Ty);
Daniel Dunbar49988882009-01-13 02:25:00 +00001386 }
Mike Stump1eb44332009-09-09 15:08:12 +00001387
Chris Lattner67b00522009-03-21 09:44:56 +00001388 // This is the first use or definition of a mangled name. If there is a
1389 // deferred decl with this name, remember that we need to emit it at the end
1390 // of the file.
John McCallf746aa62010-03-19 23:29:14 +00001391 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner67b00522009-03-21 09:44:56 +00001392 if (DDI != DeferredDecls.end()) {
1393 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1394 // list, and remove it from DeferredDecls (since we don't need it anymore).
1395 DeferredDeclsToEmit.push_back(DDI->second);
1396 DeferredDecls.erase(DDI);
1397 }
Mike Stump1eb44332009-09-09 15:08:12 +00001398
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00001399 unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace());
Mike Stump1eb44332009-09-09 15:08:12 +00001400 llvm::GlobalVariable *GV =
1401 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
Chris Lattner99b53612009-03-21 08:03:33 +00001402 llvm::GlobalValue::ExternalLinkage,
John McCallf746aa62010-03-19 23:29:14 +00001403 0, MangledName, 0,
Hans Wennborg5e2d5de2012-06-23 11:51:46 +00001404 llvm::GlobalVariable::NotThreadLocal, AddrSpace);
Chris Lattner99b53612009-03-21 08:03:33 +00001405
1406 // Handle things which are present even on external declarations.
Chris Lattner74391b42009-03-22 21:03:39 +00001407 if (D) {
Mike Stumpf5408fe2009-05-16 07:57:57 +00001408 // FIXME: This code is overly simple and should be merged with other global
1409 // handling.
Richard Smitha9b21d22012-02-17 06:48:11 +00001410 GV->setConstant(isTypeConstant(D->getType(), false));
Chris Lattner99b53612009-03-21 08:03:33 +00001411
John McCall110e8e52010-10-29 22:22:43 +00001412 // Set linkage and visibility in case we never see a definition.
John McCallaf146032010-10-30 11:50:40 +00001413 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility();
1414 if (LV.linkage() != ExternalLinkage) {
John McCall15e310a2011-02-19 02:53:41 +00001415 // Don't set internal linkage on declarations.
John McCall110e8e52010-10-29 22:22:43 +00001416 } else {
1417 if (D->hasAttr<DLLImportAttr>())
1418 GV->setLinkage(llvm::GlobalValue::DLLImportLinkage);
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001419 else if (D->hasAttr<WeakAttr>() || D->isWeakImported())
John McCall110e8e52010-10-29 22:22:43 +00001420 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Chris Lattner99b53612009-03-21 08:03:33 +00001421
John McCallaf146032010-10-30 11:50:40 +00001422 // Set visibility on a declaration only if it's explicit.
1423 if (LV.visibilityExplicit())
1424 GV->setVisibility(GetLLVMVisibility(LV.visibility()));
John McCall110e8e52010-10-29 22:22:43 +00001425 }
Eli Friedman56ebe502009-04-19 21:05:03 +00001426
Hans Wennborgde981f32012-06-28 08:01:44 +00001427 if (D->isThreadSpecified())
1428 setTLSMode(GV, *D);
Chris Lattner74391b42009-03-22 21:03:39 +00001429 }
Mike Stump1eb44332009-09-09 15:08:12 +00001430
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00001431 if (AddrSpace != Ty->getAddressSpace())
1432 return llvm::ConstantExpr::getBitCast(GV, Ty);
1433 else
1434 return GV;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001435}
1436
Chris Lattner74391b42009-03-22 21:03:39 +00001437
Anders Carlsson3bd62022011-01-29 18:20:20 +00001438llvm::GlobalVariable *
Chris Lattner5f9e2722011-07-23 10:55:15 +00001439CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001440 llvm::Type *Ty,
Anders Carlsson3bd62022011-01-29 18:20:20 +00001441 llvm::GlobalValue::LinkageTypes Linkage) {
1442 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
1443 llvm::GlobalVariable *OldGV = 0;
1444
1445
1446 if (GV) {
1447 // Check if the variable has the right type.
1448 if (GV->getType()->getElementType() == Ty)
1449 return GV;
1450
1451 // Because C++ name mangling, the only way we can end up with an already
1452 // existing global with the same name is if it has been declared extern "C".
Nico Weberc5f80462012-10-11 10:13:44 +00001453 assert(GV->isDeclaration() && "Declaration has wrong type!");
Anders Carlsson3bd62022011-01-29 18:20:20 +00001454 OldGV = GV;
1455 }
1456
1457 // Create a new variable.
1458 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
1459 Linkage, 0, Name);
1460
1461 if (OldGV) {
1462 // Replace occurrences of the old variable if needed.
1463 GV->takeName(OldGV);
1464
1465 if (!OldGV->use_empty()) {
1466 llvm::Constant *NewPtrForOldDecl =
1467 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
1468 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
1469 }
1470
1471 OldGV->eraseFromParent();
1472 }
1473
1474 return GV;
1475}
1476
Chris Lattner74391b42009-03-22 21:03:39 +00001477/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
1478/// given global variable. If Ty is non-null and if the global doesn't exist,
Eric Christopher0ff258b2012-04-16 23:55:04 +00001479/// then it will be created with the specified type instead of whatever the
Chris Lattner74391b42009-03-22 21:03:39 +00001480/// normal requested type would be.
1481llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001482 llvm::Type *Ty) {
Chris Lattner74391b42009-03-22 21:03:39 +00001483 assert(D->hasGlobalStorage() && "Not a global variable");
1484 QualType ASTTy = D->getType();
1485 if (Ty == 0)
1486 Ty = getTypes().ConvertTypeForMem(ASTTy);
Mike Stump1eb44332009-09-09 15:08:12 +00001487
Chris Lattner2acc6e32011-07-18 04:24:23 +00001488 llvm::PointerType *PTy =
Peter Collingbourne207f4d82011-03-18 22:38:29 +00001489 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
John McCallf746aa62010-03-19 23:29:14 +00001490
Chris Lattner5f9e2722011-07-23 10:55:15 +00001491 StringRef MangledName = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +00001492 return GetOrCreateLLVMGlobal(MangledName, PTy, D);
Chris Lattner74391b42009-03-22 21:03:39 +00001493}
1494
1495/// CreateRuntimeVariable - Create a new runtime global variable with the
1496/// specified type and name.
1497llvm::Constant *
Chris Lattner2acc6e32011-07-18 04:24:23 +00001498CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001499 StringRef Name) {
John McCall1de4d4e2011-04-07 08:22:57 +00001500 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0,
Rafael Espindolac532b502011-01-18 21:07:57 +00001501 true);
Chris Lattner74391b42009-03-22 21:03:39 +00001502}
1503
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001504void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1505 assert(!D->getInit() && "Cannot emit definite definitions here!");
1506
Douglas Gregor7520bd12009-04-21 19:28:58 +00001507 if (MayDeferGeneration(D)) {
1508 // If we have not seen a reference to this variable yet, place it
1509 // into the deferred declarations table to be emitted if needed
1510 // later.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001511 StringRef MangledName = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +00001512 if (!GetGlobalValue(MangledName)) {
Anders Carlsson555b4bb2009-09-10 23:43:36 +00001513 DeferredDecls[MangledName] = D;
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001514 return;
Douglas Gregor7520bd12009-04-21 19:28:58 +00001515 }
1516 }
1517
1518 // The tentative definition is the only definition.
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001519 EmitGlobalVarDefinition(D);
1520}
1521
Douglas Gregor6fb745b2010-05-13 16:44:06 +00001522void CodeGenModule::EmitVTable(CXXRecordDecl *Class, bool DefinitionRequired) {
1523 if (DefinitionRequired)
Charles Davis9ee494f2012-06-23 23:44:00 +00001524 getCXXABI().EmitVTables(Class);
Douglas Gregor6fb745b2010-05-13 16:44:06 +00001525}
1526
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001527llvm::GlobalVariable::LinkageTypes
Anders Carlsson046c2942010-04-17 20:15:18 +00001528CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
Eli Friedmancb5d2d02011-06-10 21:53:06 +00001529 if (RD->getLinkage() != ExternalLinkage)
Douglas Gregordffb8012010-01-06 22:00:56 +00001530 return llvm::GlobalVariable::InternalLinkage;
1531
1532 if (const CXXMethodDecl *KeyFunction
1533 = RD->getASTContext().getKeyFunction(RD)) {
1534 // If this class has a key function, use that to determine the linkage of
1535 // the vtable.
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001536 const FunctionDecl *Def = 0;
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +00001537 if (KeyFunction->hasBody(Def))
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001538 KeyFunction = cast<CXXMethodDecl>(Def);
Douglas Gregordffb8012010-01-06 22:00:56 +00001539
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001540 switch (KeyFunction->getTemplateSpecializationKind()) {
1541 case TSK_Undeclared:
1542 case TSK_ExplicitSpecialization:
Anders Carlsson6d7f8472011-01-30 20:45:54 +00001543 // When compiling with optimizations turned on, we emit all vtables,
1544 // even if the key function is not defined in the current translation
1545 // unit. If this is the case, use available_externally linkage.
1546 if (!Def && CodeGenOpts.OptimizationLevel)
1547 return llvm::GlobalVariable::AvailableExternallyLinkage;
1548
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001549 if (KeyFunction->isInlined())
David Blaikie4e4d0842012-03-11 07:00:24 +00001550 return !Context.getLangOpts().AppleKext ?
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001551 llvm::GlobalVariable::LinkOnceODRLinkage :
1552 llvm::Function::InternalLinkage;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001553
1554 return llvm::GlobalVariable::ExternalLinkage;
1555
1556 case TSK_ImplicitInstantiation:
David Blaikie4e4d0842012-03-11 07:00:24 +00001557 return !Context.getLangOpts().AppleKext ?
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001558 llvm::GlobalVariable::LinkOnceODRLinkage :
1559 llvm::Function::InternalLinkage;
Anders Carlssonf502d932011-01-24 00:46:19 +00001560
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001561 case TSK_ExplicitInstantiationDefinition:
David Blaikie4e4d0842012-03-11 07:00:24 +00001562 return !Context.getLangOpts().AppleKext ?
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001563 llvm::GlobalVariable::WeakODRLinkage :
1564 llvm::Function::InternalLinkage;
Anders Carlssonf502d932011-01-24 00:46:19 +00001565
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001566 case TSK_ExplicitInstantiationDeclaration:
1567 // FIXME: Use available_externally linkage. However, this currently
1568 // breaks LLVM's build due to undefined symbols.
1569 // return llvm::GlobalVariable::AvailableExternallyLinkage;
David Blaikie4e4d0842012-03-11 07:00:24 +00001570 return !Context.getLangOpts().AppleKext ?
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001571 llvm::GlobalVariable::LinkOnceODRLinkage :
1572 llvm::Function::InternalLinkage;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001573 }
Douglas Gregordffb8012010-01-06 22:00:56 +00001574 }
1575
David Blaikie4e4d0842012-03-11 07:00:24 +00001576 if (Context.getLangOpts().AppleKext)
Fariborz Jahanian53bad4e2011-02-04 00:32:39 +00001577 return llvm::Function::InternalLinkage;
1578
Douglas Gregordffb8012010-01-06 22:00:56 +00001579 switch (RD->getTemplateSpecializationKind()) {
1580 case TSK_Undeclared:
1581 case TSK_ExplicitSpecialization:
1582 case TSK_ImplicitInstantiation:
Douglas Gregordffb8012010-01-06 22:00:56 +00001583 // FIXME: Use available_externally linkage. However, this currently
1584 // breaks LLVM's build due to undefined symbols.
1585 // return llvm::GlobalVariable::AvailableExternallyLinkage;
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001586 case TSK_ExplicitInstantiationDeclaration:
Fariborz Jahanian53bad4e2011-02-04 00:32:39 +00001587 return llvm::GlobalVariable::LinkOnceODRLinkage;
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001588
1589 case TSK_ExplicitInstantiationDefinition:
Fariborz Jahanian53bad4e2011-02-04 00:32:39 +00001590 return llvm::GlobalVariable::WeakODRLinkage;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001591 }
David Blaikie30263482012-01-20 21:50:17 +00001592
1593 llvm_unreachable("Invalid TemplateSpecializationKind!");
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001594}
1595
Chris Lattner2acc6e32011-07-18 04:24:23 +00001596CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
Ken Dyck06f486e2011-01-18 02:01:14 +00001597 return Context.toCharUnitsFromBits(
Micah Villmow25a6a842012-10-08 16:25:52 +00001598 TheDataLayout.getTypeStoreSizeInBits(Ty));
Ken Dyck687cc4a2010-01-26 13:48:07 +00001599}
1600
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001601llvm::Constant *
1602CodeGenModule::MaybeEmitGlobalStdInitializerListInitializer(const VarDecl *D,
1603 const Expr *rawInit) {
1604 ArrayRef<ExprWithCleanups::CleanupObject> cleanups;
1605 if (const ExprWithCleanups *withCleanups =
1606 dyn_cast<ExprWithCleanups>(rawInit)) {
1607 cleanups = withCleanups->getObjects();
1608 rawInit = withCleanups->getSubExpr();
1609 }
1610
1611 const InitListExpr *init = dyn_cast<InitListExpr>(rawInit);
1612 if (!init || !init->initializesStdInitializerList() ||
1613 init->getNumInits() == 0)
1614 return 0;
1615
1616 ASTContext &ctx = getContext();
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001617 unsigned numInits = init->getNumInits();
Sebastian Redl062a82c2012-02-27 23:20:01 +00001618 // FIXME: This check is here because we would otherwise silently miscompile
1619 // nested global std::initializer_lists. Better would be to have a real
1620 // implementation.
1621 for (unsigned i = 0; i < numInits; ++i) {
1622 const InitListExpr *inner = dyn_cast<InitListExpr>(init->getInit(i));
1623 if (inner && inner->initializesStdInitializerList()) {
1624 ErrorUnsupported(inner, "nested global std::initializer_list");
1625 return 0;
1626 }
1627 }
1628
1629 // Synthesize a fake VarDecl for the array and initialize that.
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001630 QualType elementType = init->getInit(0)->getType();
1631 llvm::APInt numElements(ctx.getTypeSize(ctx.getSizeType()), numInits);
1632 QualType arrayType = ctx.getConstantArrayType(elementType, numElements,
1633 ArrayType::Normal, 0);
1634
1635 IdentifierInfo *name = &ctx.Idents.get(D->getNameAsString() + "__initlist");
1636 TypeSourceInfo *sourceInfo = ctx.getTrivialTypeSourceInfo(
1637 arrayType, D->getLocation());
1638 VarDecl *backingArray = VarDecl::Create(ctx, const_cast<DeclContext*>(
1639 D->getDeclContext()),
1640 D->getLocStart(), D->getLocation(),
1641 name, arrayType, sourceInfo,
1642 SC_Static, SC_Static);
1643
1644 // Now clone the InitListExpr to initialize the array instead.
1645 // Incredible hack: we want to use the existing InitListExpr here, so we need
1646 // to tell it that it no longer initializes a std::initializer_list.
Benjamin Kramer3b6bef92012-08-24 11:54:20 +00001647 ArrayRef<Expr*> Inits(const_cast<InitListExpr*>(init)->getInits(),
1648 init->getNumInits());
1649 Expr *arrayInit = new (ctx) InitListExpr(ctx, init->getLBraceLoc(), Inits,
1650 init->getRBraceLoc());
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001651 arrayInit->setType(arrayType);
1652
1653 if (!cleanups.empty())
1654 arrayInit = ExprWithCleanups::Create(ctx, arrayInit, cleanups);
1655
1656 backingArray->setInit(arrayInit);
1657
1658 // Emit the definition of the array.
1659 EmitGlobalVarDefinition(backingArray);
1660
1661 // Inspect the initializer list to validate it and determine its type.
1662 // FIXME: doing this every time is probably inefficient; caching would be nice
1663 RecordDecl *record = init->getType()->castAs<RecordType>()->getDecl();
1664 RecordDecl::field_iterator field = record->field_begin();
1665 if (field == record->field_end()) {
1666 ErrorUnsupported(D, "weird std::initializer_list");
1667 return 0;
1668 }
1669 QualType elementPtr = ctx.getPointerType(elementType.withConst());
1670 // Start pointer.
1671 if (!ctx.hasSameType(field->getType(), elementPtr)) {
1672 ErrorUnsupported(D, "weird std::initializer_list");
1673 return 0;
1674 }
1675 ++field;
1676 if (field == record->field_end()) {
1677 ErrorUnsupported(D, "weird std::initializer_list");
1678 return 0;
1679 }
1680 bool isStartEnd = false;
1681 if (ctx.hasSameType(field->getType(), elementPtr)) {
1682 // End pointer.
1683 isStartEnd = true;
1684 } else if(!ctx.hasSameType(field->getType(), ctx.getSizeType())) {
1685 ErrorUnsupported(D, "weird std::initializer_list");
1686 return 0;
1687 }
1688
1689 // Now build an APValue representing the std::initializer_list.
1690 APValue initListValue(APValue::UninitStruct(), 0, 2);
1691 APValue &startField = initListValue.getStructField(0);
1692 APValue::LValuePathEntry startOffsetPathEntry;
1693 startOffsetPathEntry.ArrayIndex = 0;
1694 startField = APValue(APValue::LValueBase(backingArray),
1695 CharUnits::fromQuantity(0),
1696 llvm::makeArrayRef(startOffsetPathEntry),
1697 /*IsOnePastTheEnd=*/false, 0);
1698
1699 if (isStartEnd) {
1700 APValue &endField = initListValue.getStructField(1);
1701 APValue::LValuePathEntry endOffsetPathEntry;
1702 endOffsetPathEntry.ArrayIndex = numInits;
1703 endField = APValue(APValue::LValueBase(backingArray),
1704 ctx.getTypeSizeInChars(elementType) * numInits,
1705 llvm::makeArrayRef(endOffsetPathEntry),
1706 /*IsOnePastTheEnd=*/true, 0);
1707 } else {
1708 APValue &sizeField = initListValue.getStructField(1);
1709 sizeField = APValue(llvm::APSInt(numElements));
1710 }
1711
1712 // Emit the constant for the initializer_list.
Richard Smitha3ca41f2012-03-02 23:27:11 +00001713 llvm::Constant *llvmInit =
1714 EmitConstantValueForMemory(initListValue, D->getType());
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001715 assert(llvmInit && "failed to initialize as constant");
1716 return llvmInit;
1717}
1718
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00001719unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D,
1720 unsigned AddrSpace) {
1721 if (LangOpts.CUDA && CodeGenOpts.CUDAIsDevice) {
1722 if (D->hasAttr<CUDAConstantAttr>())
1723 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant);
1724 else if (D->hasAttr<CUDASharedAttr>())
1725 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared);
1726 else
1727 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device);
1728 }
1729
1730 return AddrSpace;
1731}
1732
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001733void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
Chris Lattner8f32f712007-07-14 00:23:28 +00001734 llvm::Constant *Init = 0;
Eli Friedman77ba7082008-05-30 19:50:47 +00001735 QualType ASTTy = D->getType();
Richard Smith7ca48502012-02-13 22:16:19 +00001736 CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1737 bool NeedsGlobalCtor = false;
1738 bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
Mike Stump1eb44332009-09-09 15:08:12 +00001739
Richard Smith2d6a5672012-01-14 04:30:29 +00001740 const VarDecl *InitDecl;
1741 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001742
Anders Carlsson3bb92692010-01-26 17:43:42 +00001743 if (!InitExpr) {
Eli Friedmancd5f4aa2008-05-30 20:39:54 +00001744 // This is a tentative definition; tentative definitions are
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001745 // implicitly initialized with { 0 }.
1746 //
1747 // Note that tentative definitions are only emitted at the end of
1748 // a translation unit, so they should never have incomplete
1749 // type. In addition, EmitTentativeDefinition makes sure that we
1750 // never attempt to emit a tentative definition if a real one
1751 // exists. A use may still exists, however, so we still may need
1752 // to do a RAUW.
1753 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
Anders Carlssonb0d0ea02009-08-02 21:18:22 +00001754 Init = EmitNullConstant(D->getType());
Eli Friedman77ba7082008-05-30 19:50:47 +00001755 } else {
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001756 // If this is a std::initializer_list, emit the special initializer.
1757 Init = MaybeEmitGlobalStdInitializerListInitializer(D, InitExpr);
1758 // An empty init list will perform zero-initialization, which happens
1759 // to be exactly what we want.
1760 // FIXME: It does so in a global constructor, which is *not* what we
1761 // want.
1762
Fariborz Jahanian4904bf42012-06-26 16:06:38 +00001763 if (!Init) {
1764 initializedGlobalDecl = GlobalDecl(D);
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001765 Init = EmitConstantInit(*InitDecl);
Fariborz Jahanian4904bf42012-06-26 16:06:38 +00001766 }
Eli Friedman6e656f42009-02-20 01:18:21 +00001767 if (!Init) {
Anders Carlsson3bb92692010-01-26 17:43:42 +00001768 QualType T = InitExpr->getType();
Douglas Gregorc446d182010-05-05 20:15:55 +00001769 if (D->getType()->isReferenceType())
1770 T = D->getType();
Richard Smith2d6a5672012-01-14 04:30:29 +00001771
David Blaikie4e4d0842012-03-11 07:00:24 +00001772 if (getLangOpts().CPlusPlus) {
Anders Carlsson89ed31d2009-08-08 23:24:23 +00001773 Init = EmitNullConstant(T);
Richard Smith7ca48502012-02-13 22:16:19 +00001774 NeedsGlobalCtor = true;
Anders Carlsson89ed31d2009-08-08 23:24:23 +00001775 } else {
1776 ErrorUnsupported(D, "static initializer");
1777 Init = llvm::UndefValue::get(getTypes().ConvertType(T));
1778 }
John McCallbf40cb52010-07-15 23:40:35 +00001779 } else {
1780 // We don't need an initializer, so remove the entry for the delayed
Richard Smith7ca48502012-02-13 22:16:19 +00001781 // initializer position (just in case this entry was delayed) if we
1782 // also don't need to register a destructor.
David Blaikie4e4d0842012-03-11 07:00:24 +00001783 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
John McCallbf40cb52010-07-15 23:40:35 +00001784 DelayedCXXInitPosition.erase(D);
Eli Friedman6e656f42009-02-20 01:18:21 +00001785 }
Eli Friedman77ba7082008-05-30 19:50:47 +00001786 }
Eli Friedman77ba7082008-05-30 19:50:47 +00001787
Chris Lattner2acc6e32011-07-18 04:24:23 +00001788 llvm::Type* InitType = Init->getType();
Chris Lattner570585c2009-03-21 09:16:30 +00001789 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
Mike Stump1eb44332009-09-09 15:08:12 +00001790
Chris Lattner570585c2009-03-21 09:16:30 +00001791 // Strip off a bitcast if we got one back.
1792 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
Chris Lattner9d4a15f2009-07-16 16:48:25 +00001793 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
1794 // all zero index gep.
1795 CE->getOpcode() == llvm::Instruction::GetElementPtr);
Chris Lattner570585c2009-03-21 09:16:30 +00001796 Entry = CE->getOperand(0);
1797 }
Mike Stump1eb44332009-09-09 15:08:12 +00001798
Chris Lattner570585c2009-03-21 09:16:30 +00001799 // Entry is now either a Function or GlobalVariable.
1800 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00001801
Chris Lattner570585c2009-03-21 09:16:30 +00001802 // We have a definition after a declaration with the wrong type.
1803 // We must make a new GlobalVariable* and update everything that used OldGV
1804 // (a declaration or tentative definition) with the new GlobalVariable*
1805 // (which will be a definition).
1806 //
1807 // This happens if there is a prototype for a global (e.g.
1808 // "extern int x[];") and then a definition of a different type (e.g.
1809 // "int x[10];"). This also happens when an initializer has a different type
1810 // from the type of the global (this happens with unions).
Chris Lattner570585c2009-03-21 09:16:30 +00001811 if (GV == 0 ||
1812 GV->getType()->getElementType() != InitType ||
Peter Collingbourne207f4d82011-03-18 22:38:29 +00001813 GV->getType()->getAddressSpace() !=
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00001814 GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) {
Mike Stump1eb44332009-09-09 15:08:12 +00001815
John McCallf746aa62010-03-19 23:29:14 +00001816 // Move the old entry aside so that we'll create a new one.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001817 Entry->setName(StringRef());
Daniel Dunbar232350d2009-02-19 05:36:41 +00001818
Chris Lattner570585c2009-03-21 09:16:30 +00001819 // Make a new global with the correct type, this is now guaranteed to work.
1820 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
Chris Lattner0558e792009-03-21 09:25:43 +00001821
Eli Friedman77ba7082008-05-30 19:50:47 +00001822 // Replace all uses of the old global with the new global
Mike Stump1eb44332009-09-09 15:08:12 +00001823 llvm::Constant *NewPtrForOldDecl =
Owen Anderson3c4972d2009-07-29 18:54:39 +00001824 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
Chris Lattner570585c2009-03-21 09:16:30 +00001825 Entry->replaceAllUsesWith(NewPtrForOldDecl);
Eli Friedman77ba7082008-05-30 19:50:47 +00001826
1827 // Erase the old global, since it is no longer used.
Chris Lattner570585c2009-03-21 09:16:30 +00001828 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
Chris Lattner8f32f712007-07-14 00:23:28 +00001829 }
Devang Patel8e53e722007-10-26 16:31:40 +00001830
Julien Lerouge77f68bb2011-09-09 22:41:49 +00001831 if (D->hasAttr<AnnotateAttr>())
1832 AddGlobalAnnotations(D, GV);
Nate Begeman8bd4afe2008-04-19 04:17:09 +00001833
Chris Lattner88a69ad2007-07-13 05:13:43 +00001834 GV->setInitializer(Init);
Chris Lattnere78b86f2009-08-05 05:20:29 +00001835
1836 // If it is safe to mark the global 'constant', do so now.
Richard Smitha9b21d22012-02-17 06:48:11 +00001837 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
1838 isTypeConstant(D->getType(), true));
Mike Stump1eb44332009-09-09 15:08:12 +00001839
Ken Dyck8b752f12010-01-27 17:10:57 +00001840 GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
Richard Smitha9b21d22012-02-17 06:48:11 +00001841
Chris Lattner88a69ad2007-07-13 05:13:43 +00001842 // Set the llvm linkage type as appropriate.
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001843 llvm::GlobalValue::LinkageTypes Linkage =
1844 GetLLVMLinkageVarDefinition(D, GV);
1845 GV->setLinkage(Linkage);
1846 if (Linkage == llvm::GlobalVariable::CommonLinkage)
Chris Lattnere78b86f2009-08-05 05:20:29 +00001847 // common vars aren't constant even if declared const.
1848 GV->setConstant(false);
Daniel Dunbar7e714cd2009-04-10 20:26:50 +00001849
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001850 SetCommonAttributes(D, GV);
Daniel Dunbar04d40782009-04-14 06:00:08 +00001851
John McCall3030eb82010-11-06 09:44:32 +00001852 // Emit the initializer function if necessary.
Richard Smith7ca48502012-02-13 22:16:19 +00001853 if (NeedsGlobalCtor || NeedsGlobalDtor)
1854 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
John McCall3030eb82010-11-06 09:44:32 +00001855
Kostya Serebryany05c5ebc2012-08-21 06:53:28 +00001856 // If we are compiling with ASan, add metadata indicating dynamically
1857 // initialized globals.
Richard Smithca1b62a2012-11-05 21:48:12 +00001858 if (LangOpts.SanitizeAddress && NeedsGlobalCtor) {
Kostya Serebryany05c5ebc2012-08-21 06:53:28 +00001859 llvm::Module &M = getModule();
1860
1861 llvm::NamedMDNode *DynamicInitializers =
1862 M.getOrInsertNamedMetadata("llvm.asan.dynamically_initialized_globals");
1863 llvm::Value *GlobalToAdd[] = { GV };
1864 llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalToAdd);
1865 DynamicInitializers->addOperand(ThisGlobal);
1866 }
1867
Sanjiv Gupta686226b2008-06-05 08:59:10 +00001868 // Emit global variable debug information.
Eric Christopher73fb3502011-10-13 21:45:18 +00001869 if (CGDebugInfo *DI = getModuleDebugInfo())
Douglas Gregor4cdad312012-10-23 20:05:01 +00001870 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
Alexey Samsonovfd00eec2012-05-04 07:39:27 +00001871 DI->EmitGlobalVariable(GV, D);
Chris Lattner88a69ad2007-07-13 05:13:43 +00001872}
Reid Spencer5f016e22007-07-11 17:01:13 +00001873
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001874llvm::GlobalValue::LinkageTypes
1875CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D,
1876 llvm::GlobalVariable *GV) {
1877 GVALinkage Linkage = getContext().GetGVALinkageForVariable(D);
1878 if (Linkage == GVA_Internal)
1879 return llvm::Function::InternalLinkage;
1880 else if (D->hasAttr<DLLImportAttr>())
1881 return llvm::Function::DLLImportLinkage;
1882 else if (D->hasAttr<DLLExportAttr>())
1883 return llvm::Function::DLLExportLinkage;
1884 else if (D->hasAttr<WeakAttr>()) {
1885 if (GV->isConstant())
1886 return llvm::GlobalVariable::WeakODRLinkage;
1887 else
1888 return llvm::GlobalVariable::WeakAnyLinkage;
1889 } else if (Linkage == GVA_TemplateInstantiation ||
1890 Linkage == GVA_ExplicitTemplateInstantiation)
John McCall99ace162011-04-12 01:46:54 +00001891 return llvm::GlobalVariable::WeakODRLinkage;
David Blaikie4e4d0842012-03-11 07:00:24 +00001892 else if (!getLangOpts().CPlusPlus &&
Eric Christophera6cf1e72010-12-02 02:45:55 +00001893 ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) ||
1894 D->getAttr<CommonAttr>()) &&
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001895 !D->hasExternalStorage() && !D->getInit() &&
Fariborz Jahanianab27d6e2011-06-20 17:50:03 +00001896 !D->getAttr<SectionAttr>() && !D->isThreadSpecified() &&
1897 !D->getAttr<WeakImportAttr>()) {
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001898 // Thread local vars aren't considered common linkage.
1899 return llvm::GlobalVariable::CommonLinkage;
1900 }
1901 return llvm::GlobalVariable::ExternalLinkage;
1902}
1903
John McCalla923c972012-12-12 22:21:47 +00001904/// Replace the uses of a function that was declared with a non-proto type.
1905/// We want to silently drop extra arguments from call sites
1906static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
1907 llvm::Function *newFn) {
1908 // Fast path.
1909 if (old->use_empty()) return;
1910
1911 llvm::Type *newRetTy = newFn->getReturnType();
1912 SmallVector<llvm::Value*, 4> newArgs;
1913
1914 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
1915 ui != ue; ) {
1916 llvm::Value::use_iterator use = ui++; // Increment before the use is erased.
1917 llvm::User *user = *use;
1918
1919 // Recognize and replace uses of bitcasts. Most calls to
1920 // unprototyped functions will use bitcasts.
1921 if (llvm::ConstantExpr *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
1922 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
1923 replaceUsesOfNonProtoConstant(bitcast, newFn);
1924 continue;
1925 }
1926
1927 // Recognize calls to the function.
1928 llvm::CallSite callSite(user);
1929 if (!callSite) continue;
1930 if (!callSite.isCallee(use)) continue;
1931
1932 // If the return types don't match exactly, then we can't
1933 // transform this call unless it's dead.
1934 if (callSite->getType() != newRetTy && !callSite->use_empty())
1935 continue;
1936
1937 // Get the call site's attribute list.
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +00001938 SmallVector<llvm::AttributeWithIndex, 8> newAttrs;
John McCalla923c972012-12-12 22:21:47 +00001939 llvm::AttributeSet oldAttrs = callSite.getAttributes();
1940
1941 // Collect any return attributes from the call.
Bill Wendling72390b32012-12-20 19:27:06 +00001942 llvm::Attribute returnAttrs = oldAttrs.getRetAttributes();
John McCalla923c972012-12-12 22:21:47 +00001943 if (returnAttrs.hasAttributes())
1944 newAttrs.push_back(llvm::AttributeWithIndex::get(
1945 llvm::AttributeSet::ReturnIndex, returnAttrs));
1946
1947 // If the function was passed too few arguments, don't transform.
1948 unsigned newNumArgs = newFn->arg_size();
1949 if (callSite.arg_size() < newNumArgs) continue;
1950
1951 // If extra arguments were passed, we silently drop them.
1952 // If any of the types mismatch, we don't transform.
1953 unsigned argNo = 0;
1954 bool dontTransform = false;
1955 for (llvm::Function::arg_iterator ai = newFn->arg_begin(),
1956 ae = newFn->arg_end(); ai != ae; ++ai, ++argNo) {
1957 if (callSite.getArgument(argNo)->getType() != ai->getType()) {
1958 dontTransform = true;
1959 break;
1960 }
1961
1962 // Add any parameter attributes.
Bill Wendling72390b32012-12-20 19:27:06 +00001963 llvm::Attribute pAttrs = oldAttrs.getParamAttributes(argNo + 1);
John McCalla923c972012-12-12 22:21:47 +00001964 if (pAttrs.hasAttributes())
1965 newAttrs.push_back(llvm::AttributeWithIndex::get(argNo + 1, pAttrs));
1966 }
1967 if (dontTransform)
1968 continue;
1969
Bill Wendling72390b32012-12-20 19:27:06 +00001970 llvm::Attribute fnAttrs = oldAttrs.getFnAttributes();
John McCalla923c972012-12-12 22:21:47 +00001971 if (fnAttrs.hasAttributes())
1972 newAttrs.push_back(llvm::
1973 AttributeWithIndex::get(llvm::AttributeSet::FunctionIndex,
1974 fnAttrs));
1975
1976 // Okay, we can transform this. Create the new call instruction and copy
1977 // over the required information.
1978 newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo);
1979
1980 llvm::CallSite newCall;
1981 if (callSite.isCall()) {
1982 newCall = llvm::CallInst::Create(newFn, newArgs, "",
1983 callSite.getInstruction());
1984 } else {
1985 llvm::InvokeInst *oldInvoke =
1986 cast<llvm::InvokeInst>(callSite.getInstruction());
1987 newCall = llvm::InvokeInst::Create(newFn,
1988 oldInvoke->getNormalDest(),
1989 oldInvoke->getUnwindDest(),
1990 newArgs, "",
1991 callSite.getInstruction());
1992 }
1993 newArgs.clear(); // for the next iteration
1994
1995 if (!newCall->getType()->isVoidTy())
1996 newCall->takeName(callSite.getInstruction());
1997 newCall.setAttributes(
1998 llvm::AttributeSet::get(newFn->getContext(), newAttrs));
1999 newCall.setCallingConv(callSite.getCallingConv());
2000
2001 // Finally, remove the old call, replacing any uses with the new one.
2002 if (!callSite->use_empty())
2003 callSite->replaceAllUsesWith(newCall.getInstruction());
2004
2005 // Copy debug location attached to CI.
2006 if (!callSite->getDebugLoc().isUnknown())
2007 newCall->setDebugLoc(callSite->getDebugLoc());
2008 callSite->eraseFromParent();
2009 }
2010}
2011
Chris Lattnerbdb01322009-05-05 06:16:31 +00002012/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
2013/// implement a function with no prototype, e.g. "int foo() {}". If there are
2014/// existing call uses of the old function in the module, this adjusts them to
2015/// call the new function directly.
2016///
2017/// This is not just a cleanup: the always_inline pass requires direct calls to
2018/// functions to be able to inline them. If there is a bitcast in the way, it
2019/// won't inline them. Instcombine normally deletes these calls, but it isn't
2020/// run at -O0.
2021static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
2022 llvm::Function *NewFn) {
2023 // If we're redefining a global as a function, don't transform it.
John McCalla923c972012-12-12 22:21:47 +00002024 if (!isa<llvm::Function>(Old)) return;
Mike Stump1eb44332009-09-09 15:08:12 +00002025
John McCalla923c972012-12-12 22:21:47 +00002026 replaceUsesOfNonProtoConstant(Old, NewFn);
Chris Lattnerbdb01322009-05-05 06:16:31 +00002027}
2028
Rafael Espindola02503932012-03-08 15:51:03 +00002029void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
2030 TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind();
2031 // If we have a definition, this might be a deferred decl. If the
2032 // instantiation is explicit, make sure we emit it at the end.
2033 if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
2034 GetAddrOfGlobalVar(VD);
Rafael Espindola234fe652012-03-05 10:54:55 +00002035}
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00002036
Chris Lattnerb4880ba2009-05-12 21:21:08 +00002037void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
Chris Lattnerb4880ba2009-05-12 21:21:08 +00002038 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
John McCalld26bc762011-03-09 04:27:21 +00002039
John McCall1f6f9612011-03-09 08:12:35 +00002040 // Compute the function info and LLVM type.
John McCallde5d3c72012-02-17 03:33:10 +00002041 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
2042 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
John McCalld26bc762011-03-09 04:27:21 +00002043
Chris Lattner9fa959d2009-05-12 20:58:15 +00002044 // Get or create the prototype for the function.
Chris Lattnerb4880ba2009-05-12 21:21:08 +00002045 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
Mike Stump1eb44332009-09-09 15:08:12 +00002046
Chris Lattner0558e792009-03-21 09:25:43 +00002047 // Strip off a bitcast if we got one back.
2048 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
2049 assert(CE->getOpcode() == llvm::Instruction::BitCast);
2050 Entry = CE->getOperand(0);
2051 }
Mike Stump1eb44332009-09-09 15:08:12 +00002052
2053
Chris Lattner0558e792009-03-21 09:25:43 +00002054 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00002055 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00002056
Daniel Dunbar42745812009-03-09 23:53:08 +00002057 // If the types mismatch then we have to rewrite the definition.
Chris Lattnerbdb01322009-05-05 06:16:31 +00002058 assert(OldFn->isDeclaration() &&
Chris Lattner0558e792009-03-21 09:25:43 +00002059 "Shouldn't replace non-declaration");
Chris Lattner34809502009-03-21 08:53:37 +00002060
Chris Lattner62b33ea2009-03-21 08:38:50 +00002061 // F is the Function* for the one with the wrong type, we must make a new
2062 // Function* and update everything that used F (a declaration) with the new
2063 // Function* (which will be a definition).
2064 //
2065 // This happens if there is a prototype for a function
2066 // (e.g. "int f()") and then a definition of a different type
John McCallf746aa62010-03-19 23:29:14 +00002067 // (e.g. "int f(int x)"). Move the old function aside so that it
2068 // doesn't interfere with GetAddrOfFunction.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002069 OldFn->setName(StringRef());
Chris Lattnerb4880ba2009-05-12 21:21:08 +00002070 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
Mike Stump1eb44332009-09-09 15:08:12 +00002071
John McCalla923c972012-12-12 22:21:47 +00002072 // This might be an implementation of a function without a
2073 // prototype, in which case, try to do special replacement of
2074 // calls which match the new prototype. The really key thing here
2075 // is that we also potentially drop arguments from the call site
2076 // so as to make a direct call, which makes the inliner happier
2077 // and suppresses a number of optimizer warnings (!) about
2078 // dropping arguments.
2079 if (!OldFn->use_empty()) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00002080 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
Chris Lattner9fa959d2009-05-12 20:58:15 +00002081 OldFn->removeDeadConstantUsers();
2082 }
Mike Stump1eb44332009-09-09 15:08:12 +00002083
Chris Lattner62b33ea2009-03-21 08:38:50 +00002084 // Replace uses of F with the Function we will endow with a body.
Chris Lattnerbdb01322009-05-05 06:16:31 +00002085 if (!Entry->use_empty()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002086 llvm::Constant *NewPtrForOldDecl =
Owen Anderson3c4972d2009-07-29 18:54:39 +00002087 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
Chris Lattnerbdb01322009-05-05 06:16:31 +00002088 Entry->replaceAllUsesWith(NewPtrForOldDecl);
2089 }
Mike Stump1eb44332009-09-09 15:08:12 +00002090
Chris Lattner62b33ea2009-03-21 08:38:50 +00002091 // Ok, delete the old function now, which is dead.
Chris Lattnerbdb01322009-05-05 06:16:31 +00002092 OldFn->eraseFromParent();
Mike Stump1eb44332009-09-09 15:08:12 +00002093
Chris Lattner0558e792009-03-21 09:25:43 +00002094 Entry = NewFn;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00002095 }
Mike Stump1eb44332009-09-09 15:08:12 +00002096
John McCall112c9672010-11-02 21:04:24 +00002097 // We need to set linkage and visibility on the function before
2098 // generating code for it because various parts of IR generation
2099 // want to propagate this information down (e.g. to local static
2100 // declarations).
Chris Lattner0558e792009-03-21 09:25:43 +00002101 llvm::Function *Fn = cast<llvm::Function>(Entry);
John McCall8b242332010-05-25 04:30:21 +00002102 setFunctionLinkage(D, Fn);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00002103
John McCall112c9672010-11-02 21:04:24 +00002104 // FIXME: this is redundant with part of SetFunctionDefinitionAttributes
Anders Carlsson0ffeaad2011-01-29 19:39:23 +00002105 setGlobalVisibility(Fn, D);
John McCall112c9672010-11-02 21:04:24 +00002106
John McCalld26bc762011-03-09 04:27:21 +00002107 CodeGenFunction(*this).GenerateCode(D, Fn, FI);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +00002108
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002109 SetFunctionDefinitionAttributes(D, Fn);
2110 SetLLVMFunctionAttributesForDefinition(D, Fn);
Mike Stump1eb44332009-09-09 15:08:12 +00002111
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002112 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
Daniel Dunbar219df662008-09-08 23:44:31 +00002113 AddGlobalCtor(Fn, CA->getPriority());
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002114 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
Daniel Dunbar219df662008-09-08 23:44:31 +00002115 AddGlobalDtor(Fn, DA->getPriority());
Julien Lerouge77f68bb2011-09-09 22:41:49 +00002116 if (D->hasAttr<AnnotateAttr>())
2117 AddGlobalAnnotations(D, Fn);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00002118}
2119
John McCallf746aa62010-03-19 23:29:14 +00002120void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
2121 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002122 const AliasAttr *AA = D->getAttr<AliasAttr>();
Chris Lattnerbd532712009-03-22 21:47:11 +00002123 assert(AA && "Not an alias?");
2124
Chris Lattner5f9e2722011-07-23 10:55:15 +00002125 StringRef MangledName = getMangledName(GD);
Mike Stump1eb44332009-09-09 15:08:12 +00002126
John McCallf746aa62010-03-19 23:29:14 +00002127 // If there is a definition in the module, then it wins over the alias.
2128 // This is dubious, but allow it to be safe. Just ignore the alias.
2129 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
2130 if (Entry && !Entry->isDeclaration())
2131 return;
2132
Chris Lattner2acc6e32011-07-18 04:24:23 +00002133 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
Chris Lattnerbd532712009-03-22 21:47:11 +00002134
2135 // Create a reference to the named value. This ensures that it is emitted
2136 // if a deferred decl.
2137 llvm::Constant *Aliasee;
2138 if (isa<llvm::FunctionType>(DeclTy))
Alex Rosenbergc857ce82012-10-05 23:12:53 +00002139 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
Anders Carlsson1faa89f2011-02-05 04:35:53 +00002140 /*ForVTable=*/false);
Chris Lattnerbd532712009-03-22 21:47:11 +00002141 else
John McCallf746aa62010-03-19 23:29:14 +00002142 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Owen Anderson96e0fc72009-07-29 22:16:19 +00002143 llvm::PointerType::getUnqual(DeclTy), 0);
Chris Lattnerbd532712009-03-22 21:47:11 +00002144
2145 // Create the new alias itself, but don't set a name yet.
Mike Stump1eb44332009-09-09 15:08:12 +00002146 llvm::GlobalValue *GA =
Chris Lattnerbd532712009-03-22 21:47:11 +00002147 new llvm::GlobalAlias(Aliasee->getType(),
2148 llvm::Function::ExternalLinkage,
2149 "", Aliasee, &getModule());
Mike Stump1eb44332009-09-09 15:08:12 +00002150
Chris Lattnerbd532712009-03-22 21:47:11 +00002151 if (Entry) {
John McCallf746aa62010-03-19 23:29:14 +00002152 assert(Entry->isDeclaration());
2153
Chris Lattnerbd532712009-03-22 21:47:11 +00002154 // If there is a declaration in the module, then we had an extern followed
2155 // by the alias, as in:
2156 // extern int test6();
2157 // ...
2158 // int test6() __attribute__((alias("test7")));
2159 //
2160 // Remove it and replace uses of it with the alias.
John McCallf746aa62010-03-19 23:29:14 +00002161 GA->takeName(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00002162
Owen Anderson3c4972d2009-07-29 18:54:39 +00002163 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
Chris Lattnerbd532712009-03-22 21:47:11 +00002164 Entry->getType()));
Chris Lattnerbd532712009-03-22 21:47:11 +00002165 Entry->eraseFromParent();
John McCallf746aa62010-03-19 23:29:14 +00002166 } else {
Anders Carlsson9a20d552010-06-22 16:16:50 +00002167 GA->setName(MangledName);
Chris Lattnerbd532712009-03-22 21:47:11 +00002168 }
Mike Stump1eb44332009-09-09 15:08:12 +00002169
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002170 // Set attributes which are particular to an alias; this is a
2171 // specialization of the attributes which may be set on a global
2172 // variable/function.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002173 if (D->hasAttr<DLLExportAttr>()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002174 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2175 // The dllexport attribute is ignored for undefined symbols.
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +00002176 if (FD->hasBody())
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002177 GA->setLinkage(llvm::Function::DLLExportLinkage);
2178 } else {
2179 GA->setLinkage(llvm::Function::DLLExportLinkage);
2180 }
Mike Stump1eb44332009-09-09 15:08:12 +00002181 } else if (D->hasAttr<WeakAttr>() ||
Rafael Espindola11e8ce72010-02-23 22:00:30 +00002182 D->hasAttr<WeakRefAttr>() ||
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002183 D->isWeakImported()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002184 GA->setLinkage(llvm::Function::WeakAnyLinkage);
2185 }
2186
2187 SetCommonAttributes(D, GA);
Chris Lattnerbd532712009-03-22 21:47:11 +00002188}
2189
Benjamin Kramer8dd55a32011-07-14 17:45:50 +00002190llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
Chris Lattner2d3ba4f2011-07-23 17:14:25 +00002191 ArrayRef<llvm::Type*> Tys) {
Jay Foaddf983a82011-07-12 14:06:48 +00002192 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
Benjamin Kramer8dd55a32011-07-14 17:45:50 +00002193 Tys);
Chris Lattner7acda7c2007-12-18 00:25:38 +00002194}
Chris Lattnerbef20ac2007-08-31 04:31:45 +00002195
Daniel Dunbar1d552912009-07-23 22:52:48 +00002196static llvm::StringMapEntry<llvm::Constant*> &
2197GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
2198 const StringLiteral *Literal,
Daniel Dunbar70ee9752009-07-23 23:41:22 +00002199 bool TargetIsLSB,
Daniel Dunbar1d552912009-07-23 22:52:48 +00002200 bool &IsUTF16,
2201 unsigned &StringLength) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00002202 StringRef String = Literal->getString();
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00002203 unsigned NumBytes = String.size();
Daniel Dunbar1d552912009-07-23 22:52:48 +00002204
Daniel Dunbarf015b032009-09-22 10:03:52 +00002205 // Check for simple case.
2206 if (!Literal->containsNonAsciiOrNull()) {
2207 StringLength = NumBytes;
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00002208 return Map.GetOrCreateValue(String);
Daniel Dunbarf015b032009-09-22 10:03:52 +00002209 }
2210
Bill Wendling84392d02012-03-30 00:26:17 +00002211 // Otherwise, convert the UTF8 literals into a string of shorts.
2212 IsUTF16 = true;
2213
2214 SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
Roman Divacky31ba6132012-09-06 15:59:27 +00002215 const UTF8 *FromPtr = (const UTF8 *)String.data();
Daniel Dunbar1d552912009-07-23 22:52:48 +00002216 UTF16 *ToPtr = &ToBuf[0];
Mike Stump1eb44332009-09-09 15:08:12 +00002217
Fariborz Jahaniane7ddfb92010-09-07 19:57:04 +00002218 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
2219 &ToPtr, ToPtr + NumBytes,
2220 strictConversion);
Mike Stump1eb44332009-09-09 15:08:12 +00002221
Daniel Dunbar70ee9752009-07-23 23:41:22 +00002222 // ConvertUTF8toUTF16 returns the length in ToPtr.
Daniel Dunbar1d552912009-07-23 22:52:48 +00002223 StringLength = ToPtr - &ToBuf[0];
Daniel Dunbar70ee9752009-07-23 23:41:22 +00002224
Bill Wendling84392d02012-03-30 00:26:17 +00002225 // Add an explicit null.
2226 *ToPtr = 0;
2227 return Map.
2228 GetOrCreateValue(StringRef(reinterpret_cast<const char *>(ToBuf.data()),
2229 (StringLength + 1) * 2));
Daniel Dunbar1d552912009-07-23 22:52:48 +00002230}
2231
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002232static llvm::StringMapEntry<llvm::Constant*> &
2233GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map,
Bill Wendling8322c232012-03-29 22:12:09 +00002234 const StringLiteral *Literal,
2235 unsigned &StringLength) {
2236 StringRef String = Literal->getString();
2237 StringLength = String.size();
2238 return Map.GetOrCreateValue(String);
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002239}
2240
Daniel Dunbar1d552912009-07-23 22:52:48 +00002241llvm::Constant *
2242CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
2243 unsigned StringLength = 0;
2244 bool isUTF16 = false;
2245 llvm::StringMapEntry<llvm::Constant*> &Entry =
Mike Stump1eb44332009-09-09 15:08:12 +00002246 GetConstantCFStringEntry(CFConstantStringMap, Literal,
Micah Villmow25a6a842012-10-08 16:25:52 +00002247 getDataLayout().isLittleEndian(),
Daniel Dunbar70ee9752009-07-23 23:41:22 +00002248 isUTF16, StringLength);
Mike Stump1eb44332009-09-09 15:08:12 +00002249
Daniel Dunbar1d552912009-07-23 22:52:48 +00002250 if (llvm::Constant *C = Entry.getValue())
2251 return C;
Mike Stump1eb44332009-09-09 15:08:12 +00002252
Chris Lattner8b418682012-02-07 00:39:47 +00002253 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
Daniel Dunbar3e9df992008-08-23 18:37:06 +00002254 llvm::Constant *Zeros[] = { Zero, Zero };
Mike Stump1eb44332009-09-09 15:08:12 +00002255
Chris Lattner9d4a15f2009-07-16 16:48:25 +00002256 // If we don't already have it, get __CFConstantStringClassReference.
Anders Carlssonc9e20912007-08-21 00:21:21 +00002257 if (!CFConstantStringClassRef) {
Chris Lattner2acc6e32011-07-18 04:24:23 +00002258 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00002259 Ty = llvm::ArrayType::get(Ty, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00002260 llvm::Constant *GV = CreateRuntimeVariable(Ty,
Chris Lattner9d4a15f2009-07-16 16:48:25 +00002261 "__CFConstantStringClassReference");
Daniel Dunbar3e9df992008-08-23 18:37:06 +00002262 // Decay array -> ptr
2263 CFConstantStringClassRef =
Jay Foada5c04342011-07-21 14:31:17 +00002264 llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Anders Carlssonc9e20912007-08-21 00:21:21 +00002265 }
Mike Stump1eb44332009-09-09 15:08:12 +00002266
Anders Carlssone3daa762008-11-15 18:54:24 +00002267 QualType CFTy = getContext().getCFConstantStringType();
Daniel Dunbar3e9df992008-08-23 18:37:06 +00002268
Chris Lattner2acc6e32011-07-18 04:24:23 +00002269 llvm::StructType *STy =
Anders Carlssone3daa762008-11-15 18:54:24 +00002270 cast<llvm::StructType>(getTypes().ConvertType(CFTy));
2271
Benjamin Kramer1d236ab2011-10-15 12:20:02 +00002272 llvm::Constant *Fields[4];
Douglas Gregor44b43212008-12-11 16:49:14 +00002273
Anders Carlssonc9e20912007-08-21 00:21:21 +00002274 // Class pointer.
Anders Carlsson5add6832009-08-16 05:55:31 +00002275 Fields[0] = CFConstantStringClassRef;
Mike Stump1eb44332009-09-09 15:08:12 +00002276
Anders Carlssonc9e20912007-08-21 00:21:21 +00002277 // Flags.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002278 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
Mike Stump1eb44332009-09-09 15:08:12 +00002279 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
Anders Carlsson5add6832009-08-16 05:55:31 +00002280 llvm::ConstantInt::get(Ty, 0x07C8);
2281
Anders Carlssonc9e20912007-08-21 00:21:21 +00002282 // String pointer.
Bill Wendling84392d02012-03-30 00:26:17 +00002283 llvm::Constant *C = 0;
2284 if (isUTF16) {
2285 ArrayRef<uint16_t> Arr =
David Greene5ba58a12013-01-15 22:09:41 +00002286 llvm::makeArrayRef<uint16_t>(reinterpret_cast<uint16_t*>(
2287 const_cast<char *>(Entry.getKey().data())),
Bill Wendling84392d02012-03-30 00:26:17 +00002288 Entry.getKey().size() / 2);
2289 C = llvm::ConstantDataArray::get(VMContext, Arr);
2290 } else {
2291 C = llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
2292 }
Daniel Dunbara9668e02009-04-03 00:57:44 +00002293
Chris Lattner95b851e2009-07-16 05:03:48 +00002294 llvm::GlobalValue::LinkageTypes Linkage;
Bill Wendling1bf7a3f2012-01-10 08:46:39 +00002295 if (isUTF16)
Chris Lattner278b9f02009-10-14 05:55:45 +00002296 // FIXME: why do utf strings get "_" labels instead of "L" labels?
Chris Lattner95b851e2009-07-16 05:03:48 +00002297 Linkage = llvm::GlobalValue::InternalLinkage;
Bill Wendling1bf7a3f2012-01-10 08:46:39 +00002298 else
Rafael Espindola584acf22011-03-14 17:55:00 +00002299 // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error
2300 // when using private linkage. It is not clear if this is a bug in ld
2301 // or a reasonable new restriction.
Rafael Espindoladc0f1372011-03-14 21:08:19 +00002302 Linkage = llvm::GlobalValue::LinkerPrivateLinkage;
Chris Lattner278b9f02009-10-14 05:55:45 +00002303
Bill Wendling1bf7a3f2012-01-10 08:46:39 +00002304 // Note: -fwritable-strings doesn't make the backing store strings of
2305 // CFStrings writable. (See <rdar://problem/10657500>)
Mike Stump1eb44332009-09-09 15:08:12 +00002306 llvm::GlobalVariable *GV =
Bill Wendling1bf7a3f2012-01-10 08:46:39 +00002307 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
2308 Linkage, C, ".str");
Rafael Espindolab266a1f2011-01-17 16:31:00 +00002309 GV->setUnnamedAddr(true);
Daniel Dunbara9668e02009-04-03 00:57:44 +00002310 if (isUTF16) {
Ken Dyck4da244c2010-01-26 18:46:23 +00002311 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
2312 GV->setAlignment(Align.getQuantity());
Daniel Dunbarf7e903d2011-04-12 23:30:52 +00002313 } else {
2314 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2315 GV->setAlignment(Align.getQuantity());
Daniel Dunbara9668e02009-04-03 00:57:44 +00002316 }
Bill Wendling84392d02012-03-30 00:26:17 +00002317
2318 // String.
Jay Foada5c04342011-07-21 14:31:17 +00002319 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Anders Carlsson5add6832009-08-16 05:55:31 +00002320
Bill Wendling84392d02012-03-30 00:26:17 +00002321 if (isUTF16)
2322 // Cast the UTF16 string to the correct type.
2323 Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy);
2324
Anders Carlssonc9e20912007-08-21 00:21:21 +00002325 // String length.
2326 Ty = getTypes().ConvertType(getContext().LongTy);
Anders Carlsson5add6832009-08-16 05:55:31 +00002327 Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
Mike Stump1eb44332009-09-09 15:08:12 +00002328
Anders Carlssonc9e20912007-08-21 00:21:21 +00002329 // The struct.
Owen Anderson08e25242009-07-27 22:29:56 +00002330 C = llvm::ConstantStruct::get(STy, Fields);
Mike Stump1eb44332009-09-09 15:08:12 +00002331 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2332 llvm::GlobalVariable::PrivateLinkage, C,
Chris Lattner95b851e2009-07-16 05:03:48 +00002333 "_unnamed_cfstring_");
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00002334 if (const char *Sect = getContext().getTargetInfo().getCFStringSection())
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00002335 GV->setSection(Sect);
Daniel Dunbar1d552912009-07-23 22:52:48 +00002336 Entry.setValue(GV);
Mike Stump1eb44332009-09-09 15:08:12 +00002337
Anders Carlsson0c678292007-11-01 00:41:52 +00002338 return GV;
Anders Carlssonc9e20912007-08-21 00:21:21 +00002339}
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002340
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002341static RecordDecl *
2342CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK,
2343 DeclContext *DC, IdentifierInfo *Id) {
2344 SourceLocation Loc;
David Blaikie4e4d0842012-03-11 07:00:24 +00002345 if (Ctx.getLangOpts().CPlusPlus)
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002346 return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2347 else
2348 return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2349}
2350
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00002351llvm::Constant *
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002352CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002353 unsigned StringLength = 0;
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002354 llvm::StringMapEntry<llvm::Constant*> &Entry =
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002355 GetConstantStringEntry(CFConstantStringMap, Literal, StringLength);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002356
2357 if (llvm::Constant *C = Entry.getValue())
2358 return C;
2359
Chris Lattner812234b2012-02-06 22:47:00 +00002360 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002361 llvm::Constant *Zeros[] = { Zero, Zero };
2362
Fariborz Jahanianec951e02010-04-23 22:33:39 +00002363 // If we don't already have it, get _NSConstantStringClassReference.
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002364 if (!ConstantStringClassRef) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002365 std::string StringClass(getLangOpts().ObjCConstantStringClass);
Chris Lattner2acc6e32011-07-18 04:24:23 +00002366 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002367 llvm::Constant *GV;
John McCall260611a2012-06-20 06:18:46 +00002368 if (LangOpts.ObjCRuntime.isNonFragile()) {
Fariborz Jahanian25dba5d2011-05-17 22:46:11 +00002369 std::string str =
2370 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
2371 : "OBJC_CLASS_$_" + StringClass;
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00002372 GV = getObjCRuntime().GetClassGlobal(str);
2373 // Make sure the result is of the correct type.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002374 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00002375 ConstantStringClassRef =
2376 llvm::ConstantExpr::getBitCast(GV, PTy);
2377 } else {
Fariborz Jahanian25dba5d2011-05-17 22:46:11 +00002378 std::string str =
2379 StringClass.empty() ? "_NSConstantStringClassReference"
2380 : "_" + StringClass + "ClassReference";
Chris Lattner2acc6e32011-07-18 04:24:23 +00002381 llvm::Type *PTy = llvm::ArrayType::get(Ty, 0);
Fariborz Jahanian25dba5d2011-05-17 22:46:11 +00002382 GV = CreateRuntimeVariable(PTy, str);
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00002383 // Decay array -> ptr
2384 ConstantStringClassRef =
Jay Foada5c04342011-07-21 14:31:17 +00002385 llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002386 }
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002387 }
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002388
2389 if (!NSConstantStringType) {
2390 // Construct the type for a constant NSString.
2391 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2392 Context.getTranslationUnitDecl(),
2393 &Context.Idents.get("__builtin_NSString"));
2394 D->startDefinition();
2395
2396 QualType FieldTypes[3];
2397
2398 // const int *isa;
2399 FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst());
2400 // const char *str;
2401 FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst());
2402 // unsigned int length;
2403 FieldTypes[2] = Context.UnsignedIntTy;
2404
2405 // Create fields
2406 for (unsigned i = 0; i < 3; ++i) {
2407 FieldDecl *Field = FieldDecl::Create(Context, D,
2408 SourceLocation(),
2409 SourceLocation(), 0,
2410 FieldTypes[i], /*TInfo=*/0,
2411 /*BitWidth=*/0,
2412 /*Mutable=*/false,
Richard Smithca523302012-06-10 03:12:00 +00002413 ICIS_NoInit);
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002414 Field->setAccess(AS_public);
2415 D->addDecl(Field);
2416 }
2417
2418 D->completeDefinition();
2419 QualType NSTy = Context.getTagDeclType(D);
2420 NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy));
2421 }
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002422
Benjamin Kramer1d236ab2011-10-15 12:20:02 +00002423 llvm::Constant *Fields[3];
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002424
2425 // Class pointer.
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002426 Fields[0] = ConstantStringClassRef;
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002427
2428 // String pointer.
Chris Lattner94010692012-02-05 02:30:40 +00002429 llvm::Constant *C =
2430 llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002431
2432 llvm::GlobalValue::LinkageTypes Linkage;
2433 bool isConstant;
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002434 Linkage = llvm::GlobalValue::PrivateLinkage;
David Blaikie4e4d0842012-03-11 07:00:24 +00002435 isConstant = !LangOpts.WritableStrings;
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002436
2437 llvm::GlobalVariable *GV =
2438 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
2439 ".str");
Rafael Espindola803d3072011-01-17 22:11:21 +00002440 GV->setUnnamedAddr(true);
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002441 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2442 GV->setAlignment(Align.getQuantity());
Jay Foada5c04342011-07-21 14:31:17 +00002443 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002444
2445 // String length.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002446 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002447 Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
2448
2449 // The struct.
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002450 C = llvm::ConstantStruct::get(NSConstantStringType, Fields);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002451 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2452 llvm::GlobalVariable::PrivateLinkage, C,
2453 "_unnamed_nsstring_");
2454 // FIXME. Fix section.
Fariborz Jahanianec951e02010-04-23 22:33:39 +00002455 if (const char *Sect =
John McCall260611a2012-06-20 06:18:46 +00002456 LangOpts.ObjCRuntime.isNonFragile()
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00002457 ? getContext().getTargetInfo().getNSStringNonFragileABISection()
2458 : getContext().getTargetInfo().getNSStringSection())
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002459 GV->setSection(Sect);
2460 Entry.setValue(GV);
2461
2462 return GV;
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00002463}
2464
Douglas Gregor0815b572011-08-09 17:23:49 +00002465QualType CodeGenModule::getObjCFastEnumerationStateType() {
2466 if (ObjCFastEnumerationStateType.isNull()) {
2467 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2468 Context.getTranslationUnitDecl(),
2469 &Context.Idents.get("__objcFastEnumerationState"));
2470 D->startDefinition();
2471
2472 QualType FieldTypes[] = {
2473 Context.UnsignedLongTy,
2474 Context.getPointerType(Context.getObjCIdType()),
2475 Context.getPointerType(Context.UnsignedLongTy),
2476 Context.getConstantArrayType(Context.UnsignedLongTy,
2477 llvm::APInt(32, 5), ArrayType::Normal, 0)
2478 };
2479
2480 for (size_t i = 0; i < 4; ++i) {
2481 FieldDecl *Field = FieldDecl::Create(Context,
2482 D,
2483 SourceLocation(),
2484 SourceLocation(), 0,
2485 FieldTypes[i], /*TInfo=*/0,
2486 /*BitWidth=*/0,
2487 /*Mutable=*/false,
Richard Smithca523302012-06-10 03:12:00 +00002488 ICIS_NoInit);
Douglas Gregor0815b572011-08-09 17:23:49 +00002489 Field->setAccess(AS_public);
2490 D->addDecl(Field);
2491 }
2492
2493 D->completeDefinition();
2494 ObjCFastEnumerationStateType = Context.getTagDeclType(D);
2495 }
2496
2497 return ObjCFastEnumerationStateType;
2498}
2499
Eli Friedman64f45a22011-11-01 02:23:42 +00002500llvm::Constant *
2501CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) {
2502 assert(!E->getType()->isPointerType() && "Strings are always arrays");
2503
2504 // Don't emit it as the address of the string, emit the string data itself
2505 // as an inline array.
Chris Lattner812234b2012-02-06 22:47:00 +00002506 if (E->getCharByteWidth() == 1) {
2507 SmallString<64> Str(E->getString());
2508
2509 // Resize the string to the right size, which is indicated by its type.
2510 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
2511 Str.resize(CAT->getSize().getZExtValue());
2512 return llvm::ConstantDataArray::getString(VMContext, Str, false);
2513 }
Chris Lattner94010692012-02-05 02:30:40 +00002514
2515 llvm::ArrayType *AType =
2516 cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
2517 llvm::Type *ElemTy = AType->getElementType();
2518 unsigned NumElements = AType->getNumElements();
Chris Lattnerd79ed432012-02-06 22:52:04 +00002519
2520 // Wide strings have either 2-byte or 4-byte elements.
2521 if (ElemTy->getPrimitiveSizeInBits() == 16) {
2522 SmallVector<uint16_t, 32> Elements;
2523 Elements.reserve(NumElements);
2524
2525 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2526 Elements.push_back(E->getCodeUnit(i));
2527 Elements.resize(NumElements);
2528 return llvm::ConstantDataArray::get(VMContext, Elements);
Chris Lattner94010692012-02-05 02:30:40 +00002529 }
2530
Chris Lattnerd79ed432012-02-06 22:52:04 +00002531 assert(ElemTy->getPrimitiveSizeInBits() == 32);
2532 SmallVector<uint32_t, 32> Elements;
2533 Elements.reserve(NumElements);
2534
2535 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2536 Elements.push_back(E->getCodeUnit(i));
2537 Elements.resize(NumElements);
2538 return llvm::ConstantDataArray::get(VMContext, Elements);
Eli Friedman64f45a22011-11-01 02:23:42 +00002539}
2540
Daniel Dunbar61432932008-08-13 23:20:05 +00002541/// GetAddrOfConstantStringFromLiteral - Return a pointer to a
2542/// constant array for the given string literal.
2543llvm::Constant *
2544CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
John McCalla5e19c62011-08-04 01:03:22 +00002545 CharUnits Align = getContext().getTypeAlignInChars(S->getType());
Eli Friedman64f45a22011-11-01 02:23:42 +00002546 if (S->isAscii() || S->isUTF8()) {
Chris Lattner812234b2012-02-06 22:47:00 +00002547 SmallString<64> Str(S->getString());
2548
2549 // Resize the string to the right size, which is indicated by its type.
2550 const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType());
2551 Str.resize(CAT->getSize().getZExtValue());
2552 return GetAddrOfConstantString(Str, /*GlobalName*/ 0, Align.getQuantity());
Eli Friedman7eb79c12009-11-16 05:55:46 +00002553 }
Eli Friedman64f45a22011-11-01 02:23:42 +00002554
Chris Lattner812234b2012-02-06 22:47:00 +00002555 // FIXME: the following does not memoize wide strings.
Eli Friedman64f45a22011-11-01 02:23:42 +00002556 llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
2557 llvm::GlobalVariable *GV =
2558 new llvm::GlobalVariable(getModule(),C->getType(),
David Blaikie4e4d0842012-03-11 07:00:24 +00002559 !LangOpts.WritableStrings,
Eli Friedman64f45a22011-11-01 02:23:42 +00002560 llvm::GlobalValue::PrivateLinkage,
2561 C,".str");
Seth Cantrell7d6a7c02012-01-18 12:11:32 +00002562
Eli Friedman64f45a22011-11-01 02:23:42 +00002563 GV->setAlignment(Align.getQuantity());
2564 GV->setUnnamedAddr(true);
Eli Friedman64f45a22011-11-01 02:23:42 +00002565 return GV;
Daniel Dunbar61432932008-08-13 23:20:05 +00002566}
2567
Chris Lattnereaf2bb82009-02-24 22:18:39 +00002568/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
2569/// array for the given ObjCEncodeExpr node.
2570llvm::Constant *
2571CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
2572 std::string Str;
2573 getContext().getObjCEncodingForType(E->getEncodedType(), Str);
Eli Friedmana210f352009-03-07 20:17:55 +00002574
2575 return GetAddrOfConstantCString(Str);
Chris Lattnereaf2bb82009-02-24 22:18:39 +00002576}
2577
2578
Chris Lattnera7ad98f2008-02-11 00:02:17 +00002579/// GenerateWritableString -- Creates storage for a string literal.
John McCalla5e19c62011-08-04 01:03:22 +00002580static llvm::GlobalVariable *GenerateStringLiteral(StringRef str,
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002581 bool constant,
Daniel Dunbar5fabf9d2008-10-17 21:56:50 +00002582 CodeGenModule &CGM,
John McCalla5e19c62011-08-04 01:03:22 +00002583 const char *GlobalName,
2584 unsigned Alignment) {
Daniel Dunbar61432932008-08-13 23:20:05 +00002585 // Create Constant for this string literal. Don't add a '\0'.
Owen Anderson0032b272009-08-13 21:57:51 +00002586 llvm::Constant *C =
Chris Lattner94010692012-02-05 02:30:40 +00002587 llvm::ConstantDataArray::getString(CGM.getLLVMContext(), str, false);
Mike Stump1eb44332009-09-09 15:08:12 +00002588
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002589 // Create a global variable for this string
Rafael Espindola1257bc62011-01-10 22:34:03 +00002590 llvm::GlobalVariable *GV =
2591 new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
2592 llvm::GlobalValue::PrivateLinkage,
2593 C, GlobalName);
John McCalla5e19c62011-08-04 01:03:22 +00002594 GV->setAlignment(Alignment);
Rafael Espindola1257bc62011-01-10 22:34:03 +00002595 GV->setUnnamedAddr(true);
2596 return GV;
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002597}
2598
Daniel Dunbar61432932008-08-13 23:20:05 +00002599/// GetAddrOfConstantString - Returns a pointer to a character array
2600/// containing the literal. This contents are exactly that of the
2601/// given string, i.e. it will not be null terminated automatically;
2602/// see GetAddrOfConstantCString. Note that whether the result is
2603/// actually a pointer to an LLVM constant depends on
2604/// Feature.WriteableStrings.
2605///
2606/// The result has pointer to array type.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002607llvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str,
John McCalla5e19c62011-08-04 01:03:22 +00002608 const char *GlobalName,
2609 unsigned Alignment) {
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00002610 // Get the default prefix if a name wasn't specified.
2611 if (!GlobalName)
Chris Lattner95b851e2009-07-16 05:03:48 +00002612 GlobalName = ".str";
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00002613
2614 // Don't share any string literals if strings aren't constant.
David Blaikie4e4d0842012-03-11 07:00:24 +00002615 if (LangOpts.WritableStrings)
John McCalla5e19c62011-08-04 01:03:22 +00002616 return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment);
Mike Stump1eb44332009-09-09 15:08:12 +00002617
John McCalla5e19c62011-08-04 01:03:22 +00002618 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
Benjamin Kramer9de43422011-03-05 13:45:23 +00002619 ConstantStringMap.GetOrCreateValue(Str);
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002620
John McCalla5e19c62011-08-04 01:03:22 +00002621 if (llvm::GlobalVariable *GV = Entry.getValue()) {
2622 if (Alignment > GV->getAlignment()) {
2623 GV->setAlignment(Alignment);
2624 }
2625 return GV;
2626 }
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002627
2628 // Create a global variable for this.
Chris Lattner812234b2012-02-06 22:47:00 +00002629 llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName,
2630 Alignment);
John McCalla5e19c62011-08-04 01:03:22 +00002631 Entry.setValue(GV);
2632 return GV;
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002633}
Daniel Dunbar61432932008-08-13 23:20:05 +00002634
2635/// GetAddrOfConstantCString - Returns a pointer to a character
Benjamin Kramer9de43422011-03-05 13:45:23 +00002636/// array containing the literal and a terminating '\0'
Daniel Dunbar61432932008-08-13 23:20:05 +00002637/// character. The result has pointer to array type.
Benjamin Kramer9de43422011-03-05 13:45:23 +00002638llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str,
John McCalla5e19c62011-08-04 01:03:22 +00002639 const char *GlobalName,
2640 unsigned Alignment) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00002641 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
John McCalla5e19c62011-08-04 01:03:22 +00002642 return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment);
Daniel Dunbar61432932008-08-13 23:20:05 +00002643}
Daniel Dunbar41071de2008-08-15 23:26:23 +00002644
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002645/// EmitObjCPropertyImplementations - Emit information for synthesized
2646/// properties for an implementation.
Mike Stump1eb44332009-09-09 15:08:12 +00002647void CodeGenModule::EmitObjCPropertyImplementations(const
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002648 ObjCImplementationDecl *D) {
Mike Stump1eb44332009-09-09 15:08:12 +00002649 for (ObjCImplementationDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002650 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +00002651 ObjCPropertyImplDecl *PID = *i;
Mike Stump1eb44332009-09-09 15:08:12 +00002652
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002653 // Dynamic is just for type-checking.
2654 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
2655 ObjCPropertyDecl *PD = PID->getPropertyDecl();
2656
2657 // Determine which methods need to be implemented, some may have
Jordan Rose1e4691b2012-10-10 16:42:25 +00002658 // been overridden. Note that ::isPropertyAccessor is not the method
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002659 // we want, that just indicates if the decl came from a
2660 // property. What we want to know is if the method is defined in
2661 // this implementation.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002662 if (!D->getInstanceMethod(PD->getGetterName()))
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00002663 CodeGenFunction(*this).GenerateObjCGetter(
2664 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002665 if (!PD->isReadOnly() &&
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002666 !D->getInstanceMethod(PD->getSetterName()))
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00002667 CodeGenFunction(*this).GenerateObjCSetter(
2668 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002669 }
2670 }
2671}
2672
John McCalle81ac692011-03-22 07:05:39 +00002673static bool needsDestructMethod(ObjCImplementationDecl *impl) {
Jordy Rosedb8264e2011-07-22 02:08:32 +00002674 const ObjCInterfaceDecl *iface = impl->getClassInterface();
2675 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
John McCalle81ac692011-03-22 07:05:39 +00002676 ivar; ivar = ivar->getNextIvar())
2677 if (ivar->getType().isDestructedType())
2678 return true;
2679
2680 return false;
2681}
2682
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002683/// EmitObjCIvarInitializations - Emit information for ivar initialization
2684/// for an implementation.
2685void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
John McCalle81ac692011-03-22 07:05:39 +00002686 // We might need a .cxx_destruct even if we don't have any ivar initializers.
2687 if (needsDestructMethod(D)) {
2688 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
2689 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
2690 ObjCMethodDecl *DTORMethod =
2691 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002692 cxxSelector, getContext().VoidTy, 0, D,
2693 /*isInstance=*/true, /*isVariadic=*/false,
Jordan Rose1e4691b2012-10-10 16:42:25 +00002694 /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002695 /*isDefined=*/false, ObjCMethodDecl::Required);
John McCalle81ac692011-03-22 07:05:39 +00002696 D->addInstanceMethod(DTORMethod);
2697 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
John McCallb03527a2012-10-17 04:53:31 +00002698 D->setHasDestructors(true);
John McCalle81ac692011-03-22 07:05:39 +00002699 }
2700
2701 // If the implementation doesn't have any ivar initializers, we don't need
2702 // a .cxx_construct.
David Chisnall827bbcc2011-03-17 14:19:08 +00002703 if (D->getNumIvarInitializers() == 0)
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002704 return;
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002705
John McCalle81ac692011-03-22 07:05:39 +00002706 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
2707 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002708 // The constructor returns 'self'.
2709 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
2710 D->getLocation(),
Argyrios Kyrtzidis11d77162011-10-03 06:36:36 +00002711 D->getLocation(),
Argyrios Kyrtzidis11d77162011-10-03 06:36:36 +00002712 cxxSelector,
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002713 getContext().getObjCIdType(), 0,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002714 D, /*isInstance=*/true,
2715 /*isVariadic=*/false,
Jordan Rose1e4691b2012-10-10 16:42:25 +00002716 /*isPropertyAccessor=*/true,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002717 /*isImplicitlyDeclared=*/true,
2718 /*isDefined=*/false,
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002719 ObjCMethodDecl::Required);
2720 D->addInstanceMethod(CTORMethod);
2721 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
John McCallb03527a2012-10-17 04:53:31 +00002722 D->setHasNonZeroConstructors(true);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002723}
2724
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002725/// EmitNamespace - Emit all declarations in a namespace.
Anders Carlsson984e0682009-04-01 00:58:25 +00002726void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002727 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
Anders Carlsson984e0682009-04-01 00:58:25 +00002728 I != E; ++I)
2729 EmitTopLevelDecl(*I);
2730}
2731
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002732// EmitLinkageSpec - Emit all declarations in a linkage spec.
2733void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
Eli Friedmanf976be82009-08-01 20:48:04 +00002734 if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
2735 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002736 ErrorUnsupported(LSD, "linkage spec");
2737 return;
2738 }
2739
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002740 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
Fariborz Jahanianc1868e52012-10-26 20:22:11 +00002741 I != E; ++I) {
Fariborz Jahanian107dae42012-10-26 22:20:25 +00002742 // Meta-data for ObjC class includes references to implemented methods.
2743 // Generate class's method definitions first.
Fariborz Jahanianc1868e52012-10-26 20:22:11 +00002744 if (ObjCImplDecl *OID = dyn_cast<ObjCImplDecl>(*I)) {
2745 for (ObjCContainerDecl::method_iterator M = OID->meth_begin(),
2746 MEnd = OID->meth_end();
2747 M != MEnd; ++M)
2748 EmitTopLevelDecl(*M);
2749 }
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002750 EmitTopLevelDecl(*I);
Fariborz Jahanianc1868e52012-10-26 20:22:11 +00002751 }
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002752}
2753
Daniel Dunbar41071de2008-08-15 23:26:23 +00002754/// EmitTopLevelDecl - Emit code for a single top level declaration.
2755void CodeGenModule::EmitTopLevelDecl(Decl *D) {
2756 // If an error has occurred, stop code generation, but continue
2757 // parsing and semantic analysis (to ensure all warnings and errors
2758 // are emitted).
2759 if (Diags.hasErrorOccurred())
2760 return;
2761
Douglas Gregor16e8be22009-06-29 17:30:29 +00002762 // Ignore dependent declarations.
2763 if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
2764 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002765
Daniel Dunbar41071de2008-08-15 23:26:23 +00002766 switch (D->getKind()) {
Anders Carlsson293361a2009-08-25 13:14:46 +00002767 case Decl::CXXConversion:
Anders Carlsson2b77ba82009-04-04 20:47:02 +00002768 case Decl::CXXMethod:
Daniel Dunbar41071de2008-08-15 23:26:23 +00002769 case Decl::Function:
Douglas Gregor16e8be22009-06-29 17:30:29 +00002770 // Skip function templates
Francois Pichet8387e2a2011-04-22 22:18:13 +00002771 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2772 cast<FunctionDecl>(D)->isLateTemplateParsed())
Douglas Gregor16e8be22009-06-29 17:30:29 +00002773 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002774
Anders Carlsson555b4bb2009-09-10 23:43:36 +00002775 EmitGlobal(cast<FunctionDecl>(D));
2776 break;
2777
Daniel Dunbar41071de2008-08-15 23:26:23 +00002778 case Decl::Var:
Anders Carlsson555b4bb2009-09-10 23:43:36 +00002779 EmitGlobal(cast<VarDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002780 break;
2781
John McCall26fbc722011-04-12 01:01:22 +00002782 // Indirect fields from global anonymous structs and unions can be
2783 // ignored; only the actual variable requires IR gen support.
2784 case Decl::IndirectField:
2785 break;
2786
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002787 // C++ Decls
Daniel Dunbar41071de2008-08-15 23:26:23 +00002788 case Decl::Namespace:
Anders Carlsson984e0682009-04-01 00:58:25 +00002789 EmitNamespace(cast<NamespaceDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002790 break;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002791 // No code generation needed.
John McCall9d0c6612009-11-17 09:33:40 +00002792 case Decl::UsingShadow:
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002793 case Decl::Using:
Douglas Gregordd9967a2009-09-02 23:49:23 +00002794 case Decl::UsingDirective:
Douglas Gregor127102b2009-06-29 20:59:39 +00002795 case Decl::ClassTemplate:
2796 case Decl::FunctionTemplate:
Richard Smith3e4c6c42011-05-05 21:57:07 +00002797 case Decl::TypeAliasTemplate:
Anders Carlsson018837b2009-09-23 19:19:16 +00002798 case Decl::NamespaceAlias:
Douglas Gregor6a576ab2011-06-05 05:04:23 +00002799 case Decl::Block:
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002800 break;
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002801 case Decl::CXXConstructor:
Anders Carlsson1fe598c2009-11-24 05:16:24 +00002802 // Skip function templates
Francois Pichet8387e2a2011-04-22 22:18:13 +00002803 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2804 cast<FunctionDecl>(D)->isLateTemplateParsed())
Anders Carlsson1fe598c2009-11-24 05:16:24 +00002805 return;
2806
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002807 EmitCXXConstructors(cast<CXXConstructorDecl>(D));
2808 break;
Anders Carlsson27ae5362009-04-17 01:58:57 +00002809 case Decl::CXXDestructor:
Francois Pichet8387e2a2011-04-22 22:18:13 +00002810 if (cast<FunctionDecl>(D)->isLateTemplateParsed())
2811 return;
Anders Carlsson27ae5362009-04-17 01:58:57 +00002812 EmitCXXDestructors(cast<CXXDestructorDecl>(D));
2813 break;
Anders Carlsson36674d22009-06-11 21:22:55 +00002814
2815 case Decl::StaticAssert:
2816 // Nothing to do.
2817 break;
2818
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002819 // Objective-C Decls
Mike Stump1eb44332009-09-09 15:08:12 +00002820
Fariborz Jahanian38e24c72009-03-18 22:33:24 +00002821 // Forward declarations, no (immediate) code generation.
Chris Lattner285d0db2009-04-01 02:36:43 +00002822 case Decl::ObjCInterface:
Eric Christopherffb0c3a2012-07-19 22:22:55 +00002823 case Decl::ObjCCategory:
Chris Lattner285d0db2009-04-01 02:36:43 +00002824 break;
2825
Douglas Gregorbd9482d2012-01-01 21:23:57 +00002826 case Decl::ObjCProtocol: {
2827 ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(D);
2828 if (Proto->isThisDeclarationADefinition())
2829 ObjCRuntime->GenerateProtocol(Proto);
Daniel Dunbar41071de2008-08-15 23:26:23 +00002830 break;
Douglas Gregorbd9482d2012-01-01 21:23:57 +00002831 }
2832
Daniel Dunbar41071de2008-08-15 23:26:23 +00002833 case Decl::ObjCCategoryImpl:
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002834 // Categories have properties but don't support synthesize so we
2835 // can ignore them here.
Peter Collingbournee9265232011-07-27 20:29:46 +00002836 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002837 break;
2838
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002839 case Decl::ObjCImplementation: {
2840 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
2841 EmitObjCPropertyImplementations(OMD);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002842 EmitObjCIvarInitializations(OMD);
Peter Collingbournee9265232011-07-27 20:29:46 +00002843 ObjCRuntime->GenerateClass(OMD);
Eric Christopherbe6c6862012-04-11 05:56:05 +00002844 // Emit global variable debug information.
2845 if (CGDebugInfo *DI = getModuleDebugInfo())
Alexey Samsonov96a66392012-12-03 18:28:12 +00002846 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
2847 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
2848 OMD->getClassInterface()), OMD->getLocation());
Daniel Dunbar41071de2008-08-15 23:26:23 +00002849 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002850 }
Daniel Dunbar41071de2008-08-15 23:26:23 +00002851 case Decl::ObjCMethod: {
2852 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
2853 // If this is not a prototype, emit the body.
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +00002854 if (OMD->getBody())
Daniel Dunbar41071de2008-08-15 23:26:23 +00002855 CodeGenFunction(*this).GenerateObjCMethod(OMD);
2856 break;
2857 }
Mike Stump1eb44332009-09-09 15:08:12 +00002858 case Decl::ObjCCompatibleAlias:
David Chisnall29254f42012-01-31 18:59:20 +00002859 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002860 break;
2861
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002862 case Decl::LinkageSpec:
2863 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002864 break;
Daniel Dunbar41071de2008-08-15 23:26:23 +00002865
2866 case Decl::FileScopeAsm: {
2867 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
Chris Lattner5f9e2722011-07-23 10:55:15 +00002868 StringRef AsmString = AD->getAsmString()->getString();
Mike Stump1eb44332009-09-09 15:08:12 +00002869
Daniel Dunbar41071de2008-08-15 23:26:23 +00002870 const std::string &S = getModule().getModuleInlineAsm();
2871 if (S.empty())
2872 getModule().setModuleInlineAsm(AsmString);
Joerg Sonnenberger8ce9cca2012-08-10 10:57:52 +00002873 else if (S.end()[-1] == '\n')
Chris Lattner9f5bff02011-07-23 20:04:25 +00002874 getModule().setModuleInlineAsm(S + AsmString.str());
Daniel Dunbar41071de2008-08-15 23:26:23 +00002875 else
Benjamin Kramer8d042582009-12-11 13:33:18 +00002876 getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
Daniel Dunbar41071de2008-08-15 23:26:23 +00002877 break;
2878 }
Mike Stump1eb44332009-09-09 15:08:12 +00002879
Douglas Gregorb6cbe512013-01-14 17:21:00 +00002880 case Decl::Import: {
2881 ImportDecl *Import = cast<ImportDecl>(D);
2882
2883 // Ignore import declarations that come from imported modules.
2884 if (clang::Module *Owner = Import->getOwningModule()) {
2885 if (getLangOpts().CurrentModule.empty() ||
2886 Owner->getTopLevelModule()->Name == getLangOpts().CurrentModule)
2887 break;
2888 }
2889
Douglas Gregor858afb32013-01-14 20:53:57 +00002890 ImportedModules.insert(Import->getImportedModule());
Douglas Gregorb6cbe512013-01-14 17:21:00 +00002891 break;
2892 }
2893
Mike Stump1eb44332009-09-09 15:08:12 +00002894 default:
Mike Stumpf5408fe2009-05-16 07:57:57 +00002895 // Make sure we handled everything we should, every other kind is a
2896 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
2897 // function. Need to recode Decl::Kind to do that easily.
Daniel Dunbar41071de2008-08-15 23:26:23 +00002898 assert(isa<TypeDecl>(D) && "Unsupported decl kind");
2899 }
2900}
John McCall744016d2010-07-06 23:57:41 +00002901
2902/// Turns the given pointer into a constant.
2903static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
2904 const void *Ptr) {
2905 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
Chris Lattner2acc6e32011-07-18 04:24:23 +00002906 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
John McCall744016d2010-07-06 23:57:41 +00002907 return llvm::ConstantInt::get(i64, PtrInt);
2908}
2909
2910static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
2911 llvm::NamedMDNode *&GlobalMetadata,
2912 GlobalDecl D,
2913 llvm::GlobalValue *Addr) {
2914 if (!GlobalMetadata)
2915 GlobalMetadata =
2916 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
2917
2918 // TODO: should we report variant information for ctors/dtors?
2919 llvm::Value *Ops[] = {
2920 Addr,
2921 GetPointerConstant(CGM.getLLVMContext(), D.getDecl())
2922 };
Jay Foad6f141652011-04-21 19:59:12 +00002923 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
John McCall744016d2010-07-06 23:57:41 +00002924}
2925
2926/// Emits metadata nodes associating all the global values in the
2927/// current module with the Decls they came from. This is useful for
2928/// projects using IR gen as a subroutine.
2929///
2930/// Since there's currently no way to associate an MDNode directly
2931/// with an llvm::GlobalValue, we create a global named metadata
2932/// with the name 'clang.global.decl.ptrs'.
2933void CodeGenModule::EmitDeclMetadata() {
2934 llvm::NamedMDNode *GlobalMetadata = 0;
2935
2936 // StaticLocalDeclMap
Chris Lattner5f9e2722011-07-23 10:55:15 +00002937 for (llvm::DenseMap<GlobalDecl,StringRef>::iterator
John McCall744016d2010-07-06 23:57:41 +00002938 I = MangledDeclNames.begin(), E = MangledDeclNames.end();
2939 I != E; ++I) {
2940 llvm::GlobalValue *Addr = getModule().getNamedValue(I->second);
2941 EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr);
2942 }
2943}
2944
2945/// Emits metadata nodes for all the local variables in the current
2946/// function.
2947void CodeGenFunction::EmitDeclMetadata() {
2948 if (LocalDeclMap.empty()) return;
2949
2950 llvm::LLVMContext &Context = getLLVMContext();
2951
2952 // Find the unique metadata ID for this name.
2953 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
2954
2955 llvm::NamedMDNode *GlobalMetadata = 0;
2956
2957 for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator
2958 I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) {
2959 const Decl *D = I->first;
2960 llvm::Value *Addr = I->second;
2961
2962 if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
2963 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
Jay Foad6f141652011-04-21 19:59:12 +00002964 Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr));
John McCall744016d2010-07-06 23:57:41 +00002965 } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
2966 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
2967 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
2968 }
2969 }
2970}
Daniel Dunbar673431a2010-07-16 00:00:15 +00002971
Nick Lewycky3dc05412011-05-05 00:08:20 +00002972void CodeGenModule::EmitCoverageFile() {
2973 if (!getCodeGenOpts().CoverageFile.empty()) {
Nick Lewycky5ea4f442011-05-04 20:46:58 +00002974 if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) {
2975 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
2976 llvm::LLVMContext &Ctx = TheModule.getContext();
Nick Lewycky3dc05412011-05-05 00:08:20 +00002977 llvm::MDString *CoverageFile =
2978 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile);
Nick Lewycky5ea4f442011-05-04 20:46:58 +00002979 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
2980 llvm::MDNode *CU = CUNode->getOperand(i);
Nick Lewycky3dc05412011-05-05 00:08:20 +00002981 llvm::Value *node[] = { CoverageFile, CU };
Nick Lewycky5ea4f442011-05-04 20:46:58 +00002982 llvm::MDNode *N = llvm::MDNode::get(Ctx, node);
2983 GCov->addOperand(N);
2984 }
2985 }
2986 }
2987}
Nico Weberc5f80462012-10-11 10:13:44 +00002988
2989llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid,
2990 QualType GuidType) {
2991 // Sema has checked that all uuid strings are of the form
2992 // "12345678-1234-1234-1234-1234567890ab".
2993 assert(Uuid.size() == 36);
2994 const char *Uuidstr = Uuid.data();
2995 for (int i = 0; i < 36; ++i) {
2996 if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuidstr[i] == '-');
2997 else assert(isxdigit(Uuidstr[i]));
2998 }
2999
3000 llvm::APInt Field0(32, StringRef(Uuidstr , 8), 16);
3001 llvm::APInt Field1(16, StringRef(Uuidstr + 9, 4), 16);
3002 llvm::APInt Field2(16, StringRef(Uuidstr + 14, 4), 16);
Nico Weber193646f2012-10-17 00:34:34 +00003003 static const int Field3ValueOffsets[] = { 19, 21, 24, 26, 28, 30, 32, 34 };
Nico Weberc5f80462012-10-11 10:13:44 +00003004
3005 APValue InitStruct(APValue::UninitStruct(), /*NumBases=*/0, /*NumFields=*/4);
3006 InitStruct.getStructField(0) = APValue(llvm::APSInt(Field0));
3007 InitStruct.getStructField(1) = APValue(llvm::APSInt(Field1));
3008 InitStruct.getStructField(2) = APValue(llvm::APSInt(Field2));
3009 APValue& Arr = InitStruct.getStructField(3);
3010 Arr = APValue(APValue::UninitArray(), 8, 8);
3011 for (int t = 0; t < 8; ++t)
Nico Weber43085812012-10-13 21:56:05 +00003012 Arr.getArrayInitializedElt(t) = APValue(llvm::APSInt(
3013 llvm::APInt(8, StringRef(Uuidstr + Field3ValueOffsets[t], 2), 16)));
Nico Weberc5f80462012-10-11 10:13:44 +00003014
3015 return EmitConstantValue(InitStruct, GuidType);
3016}