blob: 402b309f8eca7e4ab2ac54b74cf25e92ef6a5ca1 [file] [log] [blame]
Chris Lattnerbed31442007-05-28 01:07:47 +00001//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnerbed31442007-05-28 01:07:47 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This coordinates the per-module state used while generating code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenModule.h"
Peter Collingbournefe883422011-10-06 18:29:37 +000015#include "CGCUDARuntime.h"
John McCall5d865c322010-08-31 07:33:07 +000016#include "CGCXXABI.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000017#include "CGCall.h"
18#include "CGDebugInfo.h"
Daniel Dunbar89da6ad2008-08-13 00:59:25 +000019#include "CGObjCRuntime.h"
Peter Collingbourne2dbb7082011-09-19 21:14:35 +000020#include "CGOpenCLRuntime.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000021#include "CodeGenFunction.h"
22#include "CodeGenTBAA.h"
Anton Korobeynikov55bcea12010-01-10 12:58:08 +000023#include "TargetInfo.h"
Chris Lattner2ccb73b2007-06-16 00:16:26 +000024#include "clang/AST/ASTContext.h"
Ken Dyck98ca7942010-01-26 13:48:07 +000025#include "clang/AST/CharUnits.h"
Chris Lattnerb8c18fa2008-11-04 16:51:42 +000026#include "clang/AST/DeclCXX.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000027#include "clang/AST/DeclObjC.h"
Douglas Gregor5dd34742010-06-21 18:41:26 +000028#include "clang/AST/DeclTemplate.h"
Peter Collingbourne0ff0b372011-01-13 18:57:25 +000029#include "clang/AST/Mangle.h"
Anders Carlssonb1d3f7c2009-11-30 23:41:22 +000030#include "clang/AST/RecordLayout.h"
Rafael Espindolac5941352011-10-26 20:41:06 +000031#include "clang/AST/RecursiveASTVisitor.h"
Rafael Espindola4fdc1752011-12-19 14:41:01 +000032#include "clang/Basic/Builtins.h"
Jordan Rosea7d03842013-02-08 22:30:41 +000033#include "clang/Basic/CharInfo.h"
Chris Lattnerd45aa2a2007-12-02 07:19:18 +000034#include "clang/Basic/Diagnostic.h"
Douglas Gregor6ddfca92013-01-14 17:21:00 +000035#include "clang/Basic/Module.h"
Nate Begemanfaae0812008-04-19 04:17:09 +000036#include "clang/Basic/SourceManager.h"
Chris Lattner09153c02007-06-22 18:48:09 +000037#include "clang/Basic/TargetInfo.h"
Bill Wendlingc86a2f32013-02-14 08:09:20 +000038#include "clang/Basic/TargetOptions.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000039#include "clang/Frontend/CodeGenOptions.h"
Sebastian Redl4a7eab22012-02-25 20:51:20 +000040#include "llvm/ADT/APSInt.h"
John McCallbeec5a02010-03-06 00:35:14 +000041#include "llvm/ADT/Triple.h"
Chandler Carruthffd55512013-01-02 11:45:17 +000042#include "llvm/IR/CallingConv.h"
43#include "llvm/IR/DataLayout.h"
44#include "llvm/IR/Intrinsics.h"
45#include "llvm/IR/LLVMContext.h"
46#include "llvm/IR/Module.h"
Gabor Greifd0ef1342010-04-10 02:56:12 +000047#include "llvm/Support/CallSite.h"
Dmitri Gribenko9feeef42013-01-30 12:06:08 +000048#include "llvm/Support/ConvertUTF.h"
Chris Lattner15275e52009-11-07 09:22:46 +000049#include "llvm/Support/ErrorHandling.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000050#include "llvm/Target/Mangler.h"
Dmitri Gribenko9feeef42013-01-30 12:06:08 +000051
Chris Lattnerbed31442007-05-28 01:07:47 +000052using namespace clang;
53using namespace CodeGen;
54
Julien Lerouge5a6b6982011-09-09 22:41:49 +000055static const char AnnotationSection[] = "llvm.metadata";
56
John McCall614dbdc2010-08-22 21:01:12 +000057static CGCXXABI &createCXXABI(CodeGenModule &CGM) {
John McCall359b8852013-01-25 22:30:49 +000058 switch (CGM.getContext().getTargetInfo().getCXXABI().getKind()) {
Tim Northover9bb857a2013-01-31 12:13:10 +000059 case TargetCXXABI::GenericAArch64:
John McCall57625922013-01-25 23:36:14 +000060 case TargetCXXABI::GenericARM:
61 case TargetCXXABI::iOS:
62 case TargetCXXABI::GenericItanium:
63 return *CreateItaniumCXXABI(CGM);
64 case TargetCXXABI::Microsoft:
65 return *CreateMicrosoftCXXABI(CGM);
John McCall614dbdc2010-08-22 21:01:12 +000066 }
67
68 llvm_unreachable("invalid C++ ABI kind");
John McCall614dbdc2010-08-22 21:01:12 +000069}
70
Chris Lattnerbed31442007-05-28 01:07:47 +000071
Chandler Carruthbc55fe22009-11-12 17:24:48 +000072CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
Bill Wendlingc86a2f32013-02-14 08:09:20 +000073 const TargetOptions &TO, llvm::Module &M,
74 const llvm::DataLayout &TD,
David Blaikie9c902b52011-09-25 23:23:43 +000075 DiagnosticsEngine &diags)
Bill Wendlingc86a2f32013-02-14 08:09:20 +000076 : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TargetOpts(TO),
77 TheModule(M), TheDataLayout(TD), TheTargetCodeGenInfo(0), Diags(diags),
John McCall614dbdc2010-08-22 21:01:12 +000078 ABI(createCXXABI(*this)),
John McCalla729c622012-02-17 03:33:10 +000079 Types(*this),
Dan Gohman947c9af2010-10-14 23:06:10 +000080 TBAA(0),
Peter Collingbournefe883422011-10-06 18:29:37 +000081 VTables(*this), ObjCRuntime(0), OpenCLRuntime(0), CUDARuntime(0),
Dan Gohman515a60d2012-02-16 00:57:37 +000082 DebugInfo(0), ARCData(0), NoObjCARCExceptionsMetadata(0),
83 RRData(0), CFConstantStringClassRef(0),
Peter Collingbournefe883422011-10-06 18:29:37 +000084 ConstantStringClassRef(0), NSConstantStringType(0),
Daniel Dunbar900546d2010-07-16 00:00:15 +000085 VMContext(M.getContext()),
86 NSConcreteGlobalBlock(0), NSConcreteStackBlock(0),
John McCallad7c5c12011-02-08 08:22:06 +000087 BlockObjectAssign(0), BlockObjectDispose(0),
Will Dietzf54319c2013-01-18 11:30:38 +000088 BlockDescriptorType(0), GenericBlockLiteralType(0),
89 SanitizerBlacklist(CGO.SanitizerBlacklistFile),
90 SanOpts(SanitizerBlacklist.isIn(M) ?
91 SanitizerOptions::Disabled : LangOpts.Sanitize) {
92
Chris Lattnerece04092012-02-07 00:39:47 +000093 // Initialize the type cache.
94 llvm::LLVMContext &LLVMContext = M.getContext();
95 VoidTy = llvm::Type::getVoidTy(LLVMContext);
96 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
97 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
98 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
99 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
100 FloatTy = llvm::Type::getFloatTy(LLVMContext);
101 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
102 PointerWidthInBits = C.getTargetInfo().getPointerWidth(0);
103 PointerAlignInBytes =
104 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
105 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
106 IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits);
107 Int8PtrTy = Int8Ty->getPointerTo(0);
108 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
109
John McCall882987f2013-02-28 19:01:20 +0000110 RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC();
111
David Blaikiebbafb8a2012-03-11 07:00:24 +0000112 if (LangOpts.ObjC1)
Peter Collingbourne2dbb7082011-09-19 21:14:35 +0000113 createObjCRuntime();
David Blaikiebbafb8a2012-03-11 07:00:24 +0000114 if (LangOpts.OpenCL)
Peter Collingbourne2dbb7082011-09-19 21:14:35 +0000115 createOpenCLRuntime();
David Blaikiebbafb8a2012-03-11 07:00:24 +0000116 if (LangOpts.CUDA)
Peter Collingbournefe883422011-10-06 18:29:37 +0000117 createCUDARuntime();
Sanjiv Gupta15cb6692008-05-08 08:54:20 +0000118
Kostya Serebryany5dd2cfc2012-04-24 06:57:01 +0000119 // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
Will Dietzf54319c2013-01-18 11:30:38 +0000120 if (SanOpts.Thread ||
Kostya Serebryany5dd2cfc2012-04-24 06:57:01 +0000121 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
122 TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(),
Dan Gohman2e29eb52010-10-15 20:23:12 +0000123 ABI.getMangleContext());
Dan Gohman947c9af2010-10-14 23:06:10 +0000124
Nick Lewycky207bce32011-04-21 23:44:07 +0000125 // If debug info or coverage generation is enabled, create the CGDebugInfo
126 // object.
Douglas Gregorb0eea8b2012-10-23 20:05:01 +0000127 if (CodeGenOpts.getDebugInfo() != CodeGenOptions::NoDebugInfo ||
Alexey Samsonov486e1fe2012-04-27 07:24:20 +0000128 CodeGenOpts.EmitGcovArcs ||
Nick Lewycky207bce32011-04-21 23:44:07 +0000129 CodeGenOpts.EmitGcovNotes)
130 DebugInfo = new CGDebugInfo(*this);
John McCallad7c5c12011-02-08 08:22:06 +0000131
132 Block.GlobalUniqueCount = 0;
John McCalle3dc1702011-02-15 09:22:45 +0000133
David Blaikiebbafb8a2012-03-11 07:00:24 +0000134 if (C.getLangOpts().ObjCAutoRefCount)
John McCall31168b02011-06-15 23:02:42 +0000135 ARCData = new ARCEntrypoints();
136 RRData = new RREntrypoints();
Chris Lattnera087ff92008-03-01 08:45:05 +0000137}
138
139CodeGenModule::~CodeGenModule() {
Peter Collingbournee1d20992011-07-27 20:29:46 +0000140 delete ObjCRuntime;
Peter Collingbourne2dbb7082011-09-19 21:14:35 +0000141 delete OpenCLRuntime;
Peter Collingbournefe883422011-10-06 18:29:37 +0000142 delete CUDARuntime;
Ted Kremenekc168e502011-10-08 05:28:26 +0000143 delete TheTargetCodeGenInfo;
John McCall614dbdc2010-08-22 21:01:12 +0000144 delete &ABI;
Dan Gohmand19ee8a2010-10-15 18:04:46 +0000145 delete TBAA;
Ted Kremenek2c674f62008-08-05 18:50:11 +0000146 delete DebugInfo;
John McCall31168b02011-06-15 23:02:42 +0000147 delete ARCData;
148 delete RRData;
Ted Kremenek2c674f62008-08-05 18:50:11 +0000149}
150
David Chisnall481e3a82010-01-23 02:40:42 +0000151void CodeGenModule::createObjCRuntime() {
John McCall5fb5df92012-06-20 06:18:46 +0000152 // This is just isGNUFamily(), but we want to force implementors of
153 // new ABIs to decide how best to do this.
154 switch (LangOpts.ObjCRuntime.getKind()) {
David Chisnallb601c962012-07-03 20:49:52 +0000155 case ObjCRuntime::GNUstep:
156 case ObjCRuntime::GCC:
John McCall775086e2012-07-12 02:07:58 +0000157 case ObjCRuntime::ObjFW:
Peter Collingbournee1d20992011-07-27 20:29:46 +0000158 ObjCRuntime = CreateGNUObjCRuntime(*this);
John McCall5fb5df92012-06-20 06:18:46 +0000159 return;
160
161 case ObjCRuntime::FragileMacOSX:
162 case ObjCRuntime::MacOSX:
163 case ObjCRuntime::iOS:
Peter Collingbournee1d20992011-07-27 20:29:46 +0000164 ObjCRuntime = CreateMacObjCRuntime(*this);
John McCall5fb5df92012-06-20 06:18:46 +0000165 return;
166 }
167 llvm_unreachable("bad runtime kind");
David Chisnall481e3a82010-01-23 02:40:42 +0000168}
169
Peter Collingbourne2dbb7082011-09-19 21:14:35 +0000170void CodeGenModule::createOpenCLRuntime() {
171 OpenCLRuntime = new CGOpenCLRuntime(*this);
172}
173
Peter Collingbournefe883422011-10-06 18:29:37 +0000174void CodeGenModule::createCUDARuntime() {
175 CUDARuntime = CreateNVCUDARuntime(*this);
176}
177
Ted Kremenek2c674f62008-08-05 18:50:11 +0000178void CodeGenModule::Release() {
Chris Lattnera5ae54a2009-03-22 21:21:57 +0000179 EmitDeferred();
Eli Friedman5866fe32010-01-08 00:50:11 +0000180 EmitCXXGlobalInitFunc();
Daniel Dunbarfe06df42010-03-20 04:15:41 +0000181 EmitCXXGlobalDtorFunc();
Peter Collingbournee1d20992011-07-27 20:29:46 +0000182 if (ObjCRuntime)
183 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
Daniel Dunbar8d480592008-08-11 18:12:00 +0000184 AddGlobalCtor(ObjCInitFunction);
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000185 EmitCtorList(GlobalCtors, "llvm.global_ctors");
186 EmitCtorList(GlobalDtors, "llvm.global_dtors");
Julien Lerouge5a6b6982011-09-09 22:41:49 +0000187 EmitGlobalAnnotations();
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000188 EmitLLVMUsed();
Douglas Gregorc60437f2013-01-16 01:23:41 +0000189
190 if (CodeGenOpts.ModulesAutolink) {
191 EmitModuleLinkOptions();
192 }
Douglas Gregorea02f262013-01-14 18:28:43 +0000193
John McCall0bdb1fd2010-09-16 06:16:50 +0000194 SimplifyPersonality();
195
John McCall09ae0322010-07-06 23:57:41 +0000196 if (getCodeGenOpts().EmitDeclMetadata)
197 EmitDeclMetadata();
Nick Lewycky480cb992011-05-04 20:46:58 +0000198
199 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
Nick Lewycky85c011d2011-05-05 00:08:20 +0000200 EmitCoverageFile();
Devang Patelffa30ab2011-08-16 20:58:22 +0000201
202 if (DebugInfo)
203 DebugInfo->finalize();
Daniel Dunbar23fd4622008-10-01 00:49:24 +0000204}
205
Devang Patel945b8ae2011-03-23 16:29:39 +0000206void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
207 // Make sure that this type is translated.
208 Types.UpdateCompletedType(TD);
Devang Patel945b8ae2011-03-23 16:29:39 +0000209}
210
Dan Gohman947c9af2010-10-14 23:06:10 +0000211llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) {
212 if (!TBAA)
213 return 0;
214 return TBAA->getTBAAInfo(QTy);
215}
216
Kostya Serebryany141e46f2012-03-26 17:03:51 +0000217llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() {
218 if (!TBAA)
219 return 0;
220 return TBAA->getTBAAInfoForVTablePtr();
221}
222
Dan Gohman22695fc2012-09-28 21:58:29 +0000223llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) {
224 if (!TBAA)
225 return 0;
226 return TBAA->getTBAAStructInfo(QTy);
227}
228
Dan Gohman947c9af2010-10-14 23:06:10 +0000229void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst,
230 llvm::MDNode *TBAAInfo) {
231 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo);
232}
233
John McCallbeec5a02010-03-06 00:35:14 +0000234bool CodeGenModule::isTargetDarwin() const {
Douglas Gregore8bbc122011-09-02 00:18:52 +0000235 return getContext().getTargetInfo().getTriple().isOSDarwin();
John McCallbeec5a02010-03-06 00:35:14 +0000236}
237
Chandler Carruth84537952012-03-30 19:44:53 +0000238void CodeGenModule::Error(SourceLocation loc, StringRef error) {
239 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, error);
John McCall7ef5cb32011-03-18 02:56:14 +0000240 getDiags().Report(Context.getFullLoc(loc), diagID);
241}
242
Daniel Dunbara7c8cf62008-08-16 00:56:44 +0000243/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerd45aa2a2007-12-02 07:19:18 +0000244/// specified stmt yet.
Daniel Dunbarf2cf6d12008-09-04 03:43:08 +0000245void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
246 bool OmitOnError) {
247 if (OmitOnError && getDiags().hasErrorOccurred())
248 return;
David Blaikie9c902b52011-09-25 23:23:43 +0000249 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
Daniel Dunbarfe2fb0a2009-02-06 19:18:03 +0000250 "cannot compile this %0 yet");
Chris Lattnerd45aa2a2007-12-02 07:19:18 +0000251 std::string Msg = Type;
Chris Lattner8488c822008-11-18 07:04:44 +0000252 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
253 << Msg << S->getSourceRange();
Chris Lattnerd45aa2a2007-12-02 07:19:18 +0000254}
Chris Lattner41af8182007-12-02 06:27:33 +0000255
Daniel Dunbara7c8cf62008-08-16 00:56:44 +0000256/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattner38376f12008-01-12 07:05:38 +0000257/// specified decl yet.
Daniel Dunbarf2cf6d12008-09-04 03:43:08 +0000258void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
259 bool OmitOnError) {
260 if (OmitOnError && getDiags().hasErrorOccurred())
261 return;
David Blaikie9c902b52011-09-25 23:23:43 +0000262 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
Daniel Dunbarfe2fb0a2009-02-06 19:18:03 +0000263 "cannot compile this %0 yet");
Chris Lattner38376f12008-01-12 07:05:38 +0000264 std::string Msg = Type;
Chris Lattner8488c822008-11-18 07:04:44 +0000265 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
Chris Lattner38376f12008-01-12 07:05:38 +0000266}
267
John McCall23c29fe2011-06-24 21:55:10 +0000268llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
269 return llvm::ConstantInt::get(SizeTy, size.getQuantity());
270}
271
Mike Stump11289f42009-09-09 15:08:12 +0000272void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
Anders Carlssonc6a47892011-01-29 19:39:23 +0000273 const NamedDecl *D) const {
Daniel Dunbarf5f359f2009-04-14 06:00:08 +0000274 // Internal definitions always have default visibility.
Chris Lattner6a0f9072009-04-14 05:27:13 +0000275 if (GV->hasLocalLinkage()) {
Daniel Dunbard272cca2009-04-10 20:26:50 +0000276 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar15894b72009-04-07 05:48:37 +0000277 return;
Daniel Dunbard272cca2009-04-10 20:26:50 +0000278 }
Daniel Dunbar15894b72009-04-07 05:48:37 +0000279
John McCallc273f242010-10-30 11:50:40 +0000280 // Set visibility for definitions.
Rafael Espindolaa8fbdab2013-02-27 02:15:29 +0000281 LinkageInfo LV = D->getLinkageAndVisibility();
Rafael Espindola4a5da442013-02-27 02:56:45 +0000282 if (LV.isVisibilityExplicit() || !GV->hasAvailableExternallyLinkage())
283 GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
Dan Gohman75d69da2008-05-22 00:50:06 +0000284}
285
Hans Wennborgf60f6af2012-06-28 08:01:44 +0000286static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
287 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
288 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
289 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
290 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
291 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
292}
293
294static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
295 CodeGenOptions::TLSModel M) {
296 switch (M) {
297 case CodeGenOptions::GeneralDynamicTLSModel:
298 return llvm::GlobalVariable::GeneralDynamicTLSModel;
299 case CodeGenOptions::LocalDynamicTLSModel:
300 return llvm::GlobalVariable::LocalDynamicTLSModel;
301 case CodeGenOptions::InitialExecTLSModel:
302 return llvm::GlobalVariable::InitialExecTLSModel;
303 case CodeGenOptions::LocalExecTLSModel:
304 return llvm::GlobalVariable::LocalExecTLSModel;
305 }
306 llvm_unreachable("Invalid TLS model!");
307}
308
309void CodeGenModule::setTLSMode(llvm::GlobalVariable *GV,
310 const VarDecl &D) const {
311 assert(D.isThreadSpecified() && "setting TLS mode on non-TLS var!");
312
313 llvm::GlobalVariable::ThreadLocalMode TLM;
Douglas Gregorb0eea8b2012-10-23 20:05:01 +0000314 TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel());
Hans Wennborgf60f6af2012-06-28 08:01:44 +0000315
316 // Override the TLS model if it is explicitly specified.
317 if (D.hasAttr<TLSModelAttr>()) {
318 const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>();
319 TLM = GetLLVMTLSModel(Attr->getModel());
320 }
321
322 GV->setThreadLocalMode(TLM);
323}
324
John McCalle16adc22010-08-04 08:34:44 +0000325/// Set the symbol visibility of type information (vtable and RTTI)
326/// associated with the given type.
327void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV,
328 const CXXRecordDecl *RD,
Anders Carlsson265aa7c2011-01-29 20:24:48 +0000329 TypeVisibilityKind TVK) const {
Anders Carlssonc6a47892011-01-29 19:39:23 +0000330 setGlobalVisibility(GV, RD);
John McCalle16adc22010-08-04 08:34:44 +0000331
John McCallb3732bb2010-08-12 23:36:15 +0000332 if (!CodeGenOpts.HiddenWeakVTables)
333 return;
334
Anders Carlsson678632f2011-01-29 20:36:11 +0000335 // We never want to drop the visibility for RTTI names.
336 if (TVK == TVK_ForRTTIName)
337 return;
338
John McCalle16adc22010-08-04 08:34:44 +0000339 // We want to drop the visibility to hidden for weak type symbols.
340 // This isn't possible if there might be unresolved references
341 // elsewhere that rely on this symbol being visible.
342
John McCall5513fce92010-08-05 20:39:18 +0000343 // This should be kept roughly in sync with setThunkVisibility
344 // in CGVTables.cpp.
345
John McCalle16adc22010-08-04 08:34:44 +0000346 // Preconditions.
Anders Carlsson571e2ad2011-01-24 00:46:19 +0000347 if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage ||
John McCalle16adc22010-08-04 08:34:44 +0000348 GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
349 return;
350
351 // Don't override an explicit visibility attribute.
John McCalld041a9b2013-02-20 01:54:26 +0000352 if (RD->getExplicitVisibility(NamedDecl::VisibilityForType))
John McCalle16adc22010-08-04 08:34:44 +0000353 return;
354
355 switch (RD->getTemplateSpecializationKind()) {
356 // We have to disable the optimization if this is an EI definition
357 // because there might be EI declarations in other shared objects.
358 case TSK_ExplicitInstantiationDefinition:
359 case TSK_ExplicitInstantiationDeclaration:
360 return;
361
John McCall5513fce92010-08-05 20:39:18 +0000362 // Every use of a non-template class's type information has to emit it.
John McCalle16adc22010-08-04 08:34:44 +0000363 case TSK_Undeclared:
364 break;
365
John McCall5513fce92010-08-05 20:39:18 +0000366 // In theory, implicit instantiations can ignore the possibility of
367 // an explicit instantiation declaration because there necessarily
368 // must be an EI definition somewhere with default visibility. In
369 // practice, it's possible to have an explicit instantiation for
370 // an arbitrary template class, and linkers aren't necessarily able
371 // to deal with mixed-visibility symbols.
372 case TSK_ExplicitSpecialization:
John McCalle16adc22010-08-04 08:34:44 +0000373 case TSK_ImplicitInstantiation:
Douglas Gregor47c08962012-10-24 14:11:55 +0000374 return;
John McCalle16adc22010-08-04 08:34:44 +0000375 }
376
377 // If there's a key function, there may be translation units
378 // that don't have the key function's definition. But ignore
379 // this if we're emitting RTTI under -fno-rtti.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000380 if (!(TVK != TVK_ForRTTI) || LangOpts.RTTI) {
John McCall6bd2a892013-01-25 22:31:03 +0000381 // FIXME: what should we do if we "lose" the key function during
382 // the emission of the file?
383 if (Context.getCurrentKeyFunction(RD))
John McCalle16adc22010-08-04 08:34:44 +0000384 return;
Anders Carlsson265aa7c2011-01-29 20:24:48 +0000385 }
John McCalle16adc22010-08-04 08:34:44 +0000386
387 // Otherwise, drop the visibility to hidden.
388 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Rafael Espindolab1e879c2011-01-11 21:44:37 +0000389 GV->setUnnamedAddr(true);
John McCalle16adc22010-08-04 08:34:44 +0000390}
391
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000392StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000393 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
394
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000395 StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()];
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000396 if (!Str.empty())
397 return Str;
398
John McCall5d865c322010-08-31 07:33:07 +0000399 if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000400 IdentifierInfo *II = ND->getIdentifier();
401 assert(II && "Attempt to mangle unnamed decl.");
402
403 Str = II->getName();
404 return Str;
405 }
406
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000407 SmallString<256> Buffer;
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000408 llvm::raw_svector_ostream Out(Buffer);
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000409 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000410 getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out);
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000411 else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000412 getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out);
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000413 else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND))
Fariborz Jahanian63628032012-06-26 16:06:38 +0000414 getCXXABI().getMangleContext().mangleBlock(BD, Out,
415 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()));
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000416 else
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000417 getCXXABI().getMangleContext().mangleName(ND, Out);
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000418
419 // Allocate space for the mangled name.
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000420 Out.flush();
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000421 size_t Length = Buffer.size();
422 char *Name = MangledNamesAllocator.Allocate<char>(Length);
423 std::copy(Buffer.begin(), Buffer.end(), Name);
424
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000425 Str = StringRef(Name, Length);
Anders Carlsson2e2f4d22010-06-22 16:05:32 +0000426
427 return Str;
428}
429
Peter Collingbourne0ff0b372011-01-13 18:57:25 +0000430void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer,
431 const BlockDecl *BD) {
432 MangleContext &MangleCtx = getCXXABI().getMangleContext();
433 const Decl *D = GD.getDecl();
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000434 llvm::raw_svector_ostream Out(Buffer.getBuffer());
Peter Collingbourne0ff0b372011-01-13 18:57:25 +0000435 if (D == 0)
Fariborz Jahanian63628032012-06-26 16:06:38 +0000436 MangleCtx.mangleGlobalBlock(BD,
437 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
Peter Collingbourne0ff0b372011-01-13 18:57:25 +0000438 else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000439 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
Peter Collingbourne0ff0b372011-01-13 18:57:25 +0000440 else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D))
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000441 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
Peter Collingbourne0ff0b372011-01-13 18:57:25 +0000442 else
Rafael Espindolaac00f5d2011-02-10 23:59:36 +0000443 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
Anders Carlsson635186a2010-06-09 02:36:32 +0000444}
445
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000446llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
John McCall7ec50432010-03-19 23:29:14 +0000447 return getModule().getNamedValue(Name);
Douglas Gregor5fec5b02009-02-13 00:10:09 +0000448}
449
Chris Lattner5ff2d5d2008-03-14 17:18:18 +0000450/// AddGlobalCtor - Add a function to the list that will be called before
451/// main() runs.
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000452void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
Daniel Dunbardec798b2009-01-13 02:25:00 +0000453 // FIXME: Type coercion of void()* types.
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000454 GlobalCtors.push_back(std::make_pair(Ctor, Priority));
Chris Lattner5ff2d5d2008-03-14 17:18:18 +0000455}
456
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000457/// AddGlobalDtor - Add a function to the list that will be called
458/// when the module is unloaded.
459void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
Daniel Dunbardec798b2009-01-13 02:25:00 +0000460 // FIXME: Type coercion of void()* types.
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000461 GlobalDtors.push_back(std::make_pair(Dtor, Priority));
462}
463
464void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
465 // Ctor function type is void()*.
John McCall9dc0db22011-05-15 01:53:33 +0000466 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
Owen Anderson9793f0e2009-07-29 22:16:19 +0000467 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000468
469 // Get the type of a ctor entry, { i32, void ()* }.
Chris Lattnere64d7ba2011-06-20 04:01:35 +0000470 llvm::StructType *CtorStructTy =
Chris Lattnerece04092012-02-07 00:39:47 +0000471 llvm::StructType::get(Int32Ty, llvm::PointerType::getUnqual(CtorFTy), NULL);
Chris Lattner5ff2d5d2008-03-14 17:18:18 +0000472
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000473 // Construct the constructor and destructor arrays.
Chris Lattner3def9ae2012-02-06 22:16:34 +0000474 SmallVector<llvm::Constant*, 8> Ctors;
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000475 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
Chris Lattner3def9ae2012-02-06 22:16:34 +0000476 llvm::Constant *S[] = {
477 llvm::ConstantInt::get(Int32Ty, I->second, false),
478 llvm::ConstantExpr::getBitCast(I->first, CtorPFTy)
479 };
Owen Anderson0e0189d2009-07-27 22:29:56 +0000480 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
Chris Lattner5ff2d5d2008-03-14 17:18:18 +0000481 }
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000482
483 if (!Ctors.empty()) {
Owen Anderson9793f0e2009-07-29 22:16:19 +0000484 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
Owen Andersonc10c8d32009-07-08 19:05:04 +0000485 new llvm::GlobalVariable(TheModule, AT, false,
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000486 llvm::GlobalValue::AppendingLinkage,
Owen Anderson47034e12009-07-28 18:33:04 +0000487 llvm::ConstantArray::get(AT, Ctors),
Owen Andersonc10c8d32009-07-08 19:05:04 +0000488 GlobalName);
Daniel Dunbar74aa7e12008-08-01 00:01:51 +0000489 }
Chris Lattner5ff2d5d2008-03-14 17:18:18 +0000490}
491
John McCalld4324142010-02-19 01:32:20 +0000492llvm::GlobalValue::LinkageTypes
493CodeGenModule::getFunctionLinkage(const FunctionDecl *D) {
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +0000494 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
Daniel Dunbar38932572009-04-14 08:05:55 +0000495
Chris Lattner749b8ed2010-06-30 16:58:07 +0000496 if (Linkage == GVA_Internal)
John McCalld4324142010-02-19 01:32:20 +0000497 return llvm::Function::InternalLinkage;
Chris Lattner749b8ed2010-06-30 16:58:07 +0000498
499 if (D->hasAttr<DLLExportAttr>())
John McCalld4324142010-02-19 01:32:20 +0000500 return llvm::Function::DLLExportLinkage;
Chris Lattner749b8ed2010-06-30 16:58:07 +0000501
502 if (D->hasAttr<WeakAttr>())
John McCalld4324142010-02-19 01:32:20 +0000503 return llvm::Function::WeakAnyLinkage;
Chris Lattner749b8ed2010-06-30 16:58:07 +0000504
505 // In C99 mode, 'inline' functions are guaranteed to have a strong
506 // definition somewhere else, so we can use available_externally linkage.
507 if (Linkage == GVA_C99Inline)
Fariborz Jahanian7cadb2f2011-02-04 00:08:13 +0000508 return llvm::Function::AvailableExternallyLinkage;
John McCall28a5b322011-09-19 18:05:26 +0000509
510 // Note that Apple's kernel linker doesn't support symbol
511 // coalescing, so we need to avoid linkonce and weak linkages there.
512 // Normally, this means we just map to internal, but for explicit
513 // instantiations we'll map to external.
514
Chris Lattner749b8ed2010-06-30 16:58:07 +0000515 // In C++, the compiler has to emit a definition in every translation unit
516 // that references the function. We should use linkonce_odr because
517 // a) if all references in this translation unit are optimized away, we
518 // don't need to codegen it. b) if the function persists, it needs to be
519 // merged with other definitions. c) C++ has the ODR, so we know the
520 // definition is dependable.
521 if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
David Blaikiebbafb8a2012-03-11 07:00:24 +0000522 return !Context.getLangOpts().AppleKext
Fariborz Jahanianf7f04452011-02-04 00:01:24 +0000523 ? llvm::Function::LinkOnceODRLinkage
524 : llvm::Function::InternalLinkage;
Chris Lattner749b8ed2010-06-30 16:58:07 +0000525
526 // An explicit instantiation of a template has weak linkage, since
527 // explicit instantiations can occur in multiple translation units
528 // and must all be equivalent. However, we are not allowed to
529 // throw away these explicit instantiations.
530 if (Linkage == GVA_ExplicitTemplateInstantiation)
David Blaikiebbafb8a2012-03-11 07:00:24 +0000531 return !Context.getLangOpts().AppleKext
Fariborz Jahanianf7f04452011-02-04 00:01:24 +0000532 ? llvm::Function::WeakODRLinkage
John McCall28a5b322011-09-19 18:05:26 +0000533 : llvm::Function::ExternalLinkage;
Chris Lattner749b8ed2010-06-30 16:58:07 +0000534
535 // Otherwise, we have strong external linkage.
536 assert(Linkage == GVA_StrongExternal);
537 return llvm::Function::ExternalLinkage;
John McCalld4324142010-02-19 01:32:20 +0000538}
Nuno Lopesb6f79532008-06-08 15:45:52 +0000539
John McCalld4324142010-02-19 01:32:20 +0000540
541/// SetFunctionDefinitionAttributes - Set attributes for a global.
542///
543/// FIXME: This is currently only done for aliases and functions, but not for
544/// variables (these details are set in EmitGlobalVarDefinition for variables).
545void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
546 llvm::GlobalValue *GV) {
Daniel Dunbar38932572009-04-14 08:05:55 +0000547 SetCommonAttributes(D, GV);
Nuno Lopesb6f79532008-06-08 15:45:52 +0000548}
549
Daniel Dunbaraeddffc2009-04-14 07:08:30 +0000550void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
Mike Stump11289f42009-09-09 15:08:12 +0000551 const CGFunctionInfo &Info,
Daniel Dunbaraeddffc2009-04-14 07:08:30 +0000552 llvm::Function *F) {
Daniel Dunbar0ef34792009-09-12 00:59:20 +0000553 unsigned CallingConv;
Devang Patel322300d2008-09-25 21:02:23 +0000554 AttributeListType AttributeList;
Bill Wendlingf4d64cb2013-02-22 00:13:35 +0000555 ConstructAttributeList(Info, D, AttributeList, CallingConv, false);
Bill Wendling3087d022012-12-07 23:17:26 +0000556 F->setAttributes(llvm::AttributeSet::get(getLLVMContext(), AttributeList));
Daniel Dunbar0ef34792009-09-12 00:59:20 +0000557 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbar449a3392008-09-04 23:41:35 +0000558}
559
John McCall9b0a7ce2011-10-02 01:16:38 +0000560/// Determines whether the language options require us to model
561/// unwind exceptions. We treat -fexceptions as mandating this
562/// except under the fragile ObjC ABI with only ObjC exceptions
563/// enabled. This means, for example, that C with -fexceptions
564/// enables this.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000565static bool hasUnwindExceptions(const LangOptions &LangOpts) {
John McCall9b0a7ce2011-10-02 01:16:38 +0000566 // If exceptions are completely disabled, obviously this is false.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000567 if (!LangOpts.Exceptions) return false;
John McCall9b0a7ce2011-10-02 01:16:38 +0000568
569 // If C++ exceptions are enabled, this is true.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000570 if (LangOpts.CXXExceptions) return true;
John McCall9b0a7ce2011-10-02 01:16:38 +0000571
572 // If ObjC exceptions are enabled, this depends on the ABI.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000573 if (LangOpts.ObjCExceptions) {
David Chisnallb601c962012-07-03 20:49:52 +0000574 return LangOpts.ObjCRuntime.hasUnwindExceptions();
John McCall9b0a7ce2011-10-02 01:16:38 +0000575 }
576
577 return true;
578}
579
Daniel Dunbar38932572009-04-14 08:05:55 +0000580void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
581 llvm::Function *F) {
Rafael Espindolac1ee12c2011-05-25 03:44:55 +0000582 if (CodeGenOpts.UnwindTables)
583 F->setHasUWTable();
584
David Blaikiebbafb8a2012-03-11 07:00:24 +0000585 if (!hasUnwindExceptions(LangOpts))
Bill Wendling207f0532012-12-20 19:27:06 +0000586 F->addFnAttr(llvm::Attribute::NoUnwind);
Daniel Dunbar03a38442008-10-28 00:17:57 +0000587
Eli Friedmanc55efe42011-08-22 23:55:33 +0000588 if (D->hasAttr<NakedAttr>()) {
589 // Naked implies noinline: we should not be inlining such functions.
Bill Wendling207f0532012-12-20 19:27:06 +0000590 F->addFnAttr(llvm::Attribute::Naked);
591 F->addFnAttr(llvm::Attribute::NoInline);
Eli Friedmanc55efe42011-08-22 23:55:33 +0000592 }
Daniel Dunbar8caf6412010-09-29 18:20:25 +0000593
Mike Stump3722f582009-08-26 22:31:08 +0000594 if (D->hasAttr<NoInlineAttr>())
Bill Wendling207f0532012-12-20 19:27:06 +0000595 F->addFnAttr(llvm::Attribute::NoInline);
Mike Stumpc5e153c2009-10-05 21:58:44 +0000596
Eli Friedmanc55efe42011-08-22 23:55:33 +0000597 // (noinline wins over always_inline, and we can't specify both in IR)
Michael J. Spencerf97bd8c2012-06-18 07:00:48 +0000598 if ((D->hasAttr<AlwaysInlineAttr>() || D->hasAttr<ForceInlineAttr>()) &&
Bill Wendling5e85be42012-12-30 10:32:17 +0000599 !F->getAttributes().hasAttribute(llvm::AttributeSet::FunctionIndex,
600 llvm::Attribute::NoInline))
Bill Wendling207f0532012-12-20 19:27:06 +0000601 F->addFnAttr(llvm::Attribute::AlwaysInline);
Eli Friedmanc55efe42011-08-22 23:55:33 +0000602
Benjamin Kramer29c2b432012-05-12 21:10:52 +0000603 // FIXME: Communicate hot and cold attributes to LLVM more directly.
604 if (D->hasAttr<ColdAttr>())
Bill Wendling207f0532012-12-20 19:27:06 +0000605 F->addFnAttr(llvm::Attribute::OptimizeForSize);
Benjamin Kramer29c2b432012-05-12 21:10:52 +0000606
Quentin Colombet4e172062012-11-01 23:55:47 +0000607 if (D->hasAttr<MinSizeAttr>())
Bill Wendling207f0532012-12-20 19:27:06 +0000608 F->addFnAttr(llvm::Attribute::MinSize);
Quentin Colombet4e172062012-11-01 23:55:47 +0000609
Rafael Espindola0ee986c1f2011-01-11 00:26:26 +0000610 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
611 F->setUnnamedAddr(true);
612
Richard Smithb555a762012-09-28 22:46:07 +0000613 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D))
614 if (MD->isVirtual())
615 F->setUnnamedAddr(true);
616
David Blaikiebbafb8a2012-03-11 07:00:24 +0000617 if (LangOpts.getStackProtector() == LangOptions::SSPOn)
Bill Wendling207f0532012-12-20 19:27:06 +0000618 F->addFnAttr(llvm::Attribute::StackProtect);
David Blaikiebbafb8a2012-03-11 07:00:24 +0000619 else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
Bill Wendling207f0532012-12-20 19:27:06 +0000620 F->addFnAttr(llvm::Attribute::StackProtectReq);
Will Dietzf54319c2013-01-18 11:30:38 +0000621
Alexey Samsonova1c0a2a2013-03-06 10:54:18 +0000622 // Add sanitizer attributes if function is not blacklisted.
623 if (!SanitizerBlacklist.isIn(*F)) {
624 // When AddressSanitizer is enabled, set SanitizeAddress attribute
625 // unless __attribute__((no_sanitize_address)) is used.
626 if (SanOpts.Address && !D->hasAttr<NoSanitizeAddressAttr>())
627 F->addFnAttr(llvm::Attribute::SanitizeAddress);
628 // Same for ThreadSanitizer and __attribute__((no_sanitize_thread))
629 if (SanOpts.Thread && !D->hasAttr<NoSanitizeThreadAttr>()) {
630 F->addFnAttr(llvm::Attribute::SanitizeThread);
631 }
632 // Same for MemorySanitizer and __attribute__((no_sanitize_memory))
633 if (SanOpts.Memory && !D->hasAttr<NoSanitizeMemoryAttr>())
634 F->addFnAttr(llvm::Attribute::SanitizeMemory);
635 }
Alexander Potapenkoef41fd32012-02-02 11:49:28 +0000636
Alexis Huntdcfba7b2010-08-18 23:23:40 +0000637 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
638 if (alignment)
639 F->setAlignment(alignment);
640
Mike Stump3472ae52009-10-05 22:49:20 +0000641 // C++ ABI requires 2-byte alignment for member functions.
Mike Stump916c0062009-10-05 23:08:21 +0000642 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
643 F->setAlignment(2);
Daniel Dunbar449a3392008-09-04 23:41:35 +0000644}
645
Mike Stump11289f42009-09-09 15:08:12 +0000646void CodeGenModule::SetCommonAttributes(const Decl *D,
Daniel Dunbar38932572009-04-14 08:05:55 +0000647 llvm::GlobalValue *GV) {
Anders Carlsson072ef742011-01-29 19:41:00 +0000648 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
649 setGlobalVisibility(GV, ND);
John McCall457a04e2010-10-22 21:05:15 +0000650 else
651 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar38932572009-04-14 08:05:55 +0000652
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000653 if (D->hasAttr<UsedAttr>())
Daniel Dunbar38932572009-04-14 08:05:55 +0000654 AddUsedGlobal(GV);
655
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000656 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
Daniel Dunbar38932572009-04-14 08:05:55 +0000657 GV->setSection(SA->getName());
Anton Korobeynikov55bcea12010-01-10 12:58:08 +0000658
659 getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
Daniel Dunbar38932572009-04-14 08:05:55 +0000660}
661
Daniel Dunbarc3e7cff2009-04-17 00:48:04 +0000662void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
663 llvm::Function *F,
664 const CGFunctionInfo &FI) {
665 SetLLVMFunctionAttributes(D, FI, F);
666 SetLLVMFunctionAttributesForDefinition(D, F);
Daniel Dunbar38932572009-04-14 08:05:55 +0000667
668 F->setLinkage(llvm::Function::InternalLinkage);
669
Daniel Dunbarc3e7cff2009-04-17 00:48:04 +0000670 SetCommonAttributes(D, F);
Daniel Dunbar449a3392008-09-04 23:41:35 +0000671}
672
Anders Carlsson6710c532010-02-06 02:44:09 +0000673void CodeGenModule::SetFunctionAttributes(GlobalDecl GD,
Eli Friedman895771a2009-05-26 01:22:57 +0000674 llvm::Function *F,
675 bool IsIncompleteFunction) {
Peter Collingbourneeafa4e42011-04-06 12:29:04 +0000676 if (unsigned IID = F->getIntrinsicID()) {
677 // If this is an intrinsic function, set the function's attributes
678 // to the intrinsic's attributes.
Bill Wendling311c8322012-10-15 04:47:45 +0000679 F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(),
680 (llvm::Intrinsic::ID)IID));
Peter Collingbourneeafa4e42011-04-06 12:29:04 +0000681 return;
682 }
683
Anders Carlsson6710c532010-02-06 02:44:09 +0000684 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
685
Eli Friedman895771a2009-05-26 01:22:57 +0000686 if (!IsIncompleteFunction)
John McCalla729c622012-02-17 03:33:10 +0000687 SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F);
Mike Stump11289f42009-09-09 15:08:12 +0000688
Daniel Dunbar38932572009-04-14 08:05:55 +0000689 // Only a few attributes are set on declarations; these may later be
690 // overridden by a definition.
Mike Stump11289f42009-09-09 15:08:12 +0000691
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000692 if (FD->hasAttr<DLLImportAttr>()) {
Daniel Dunbar38932572009-04-14 08:05:55 +0000693 F->setLinkage(llvm::Function::DLLImportLinkage);
Mike Stump11289f42009-09-09 15:08:12 +0000694 } else if (FD->hasAttr<WeakAttr>() ||
Douglas Gregor20b2ebd2011-03-23 00:50:03 +0000695 FD->isWeakImported()) {
Daniel Dunbar38932572009-04-14 08:05:55 +0000696 // "extern_weak" is overloaded in LLVM; we probably should have
Mike Stump11289f42009-09-09 15:08:12 +0000697 // separate linkage types for this.
Daniel Dunbar38932572009-04-14 08:05:55 +0000698 F->setLinkage(llvm::Function::ExternalWeakLinkage);
699 } else {
Mike Stump11289f42009-09-09 15:08:12 +0000700 F->setLinkage(llvm::Function::ExternalLinkage);
John McCallc273f242010-10-30 11:50:40 +0000701
Rafael Espindolaa8fbdab2013-02-27 02:15:29 +0000702 LinkageInfo LV = FD->getLinkageAndVisibility();
Rafael Espindola4a5da442013-02-27 02:56:45 +0000703 if (LV.getLinkage() == ExternalLinkage && LV.isVisibilityExplicit()) {
704 F->setVisibility(GetLLVMVisibility(LV.getVisibility()));
John McCallc273f242010-10-30 11:50:40 +0000705 }
Daniel Dunbar38932572009-04-14 08:05:55 +0000706 }
707
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000708 if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
Daniel Dunbar38932572009-04-14 08:05:55 +0000709 F->setSection(SA->getName());
Daniel Dunbar0beedc12008-09-08 23:44:31 +0000710}
711
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000712void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
Mike Stump11289f42009-09-09 15:08:12 +0000713 assert(!GV->isDeclaration() &&
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000714 "Only globals with definition can force usage.");
Chris Lattnerf41e87f2009-03-31 22:37:52 +0000715 LLVMUsed.push_back(GV);
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000716}
717
718void CodeGenModule::EmitLLVMUsed() {
719 // Don't create llvm.used if there is no need.
Chris Lattnerf56501c2009-07-17 23:57:13 +0000720 if (LLVMUsed.empty())
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000721 return;
722
Chris Lattnerf41e87f2009-03-31 22:37:52 +0000723 // Convert LLVMUsed to what ConstantArray needs.
Chris Lattner3def9ae2012-02-06 22:16:34 +0000724 SmallVector<llvm::Constant*, 8> UsedArray;
Chris Lattnerf41e87f2009-03-31 22:37:52 +0000725 UsedArray.resize(LLVMUsed.size());
726 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
Mike Stump11289f42009-09-09 15:08:12 +0000727 UsedArray[i] =
728 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
Chris Lattner3def9ae2012-02-06 22:16:34 +0000729 Int8PtrTy);
Chris Lattnerf41e87f2009-03-31 22:37:52 +0000730 }
Mike Stump11289f42009-09-09 15:08:12 +0000731
Fariborz Jahanian248c7192009-06-23 21:47:46 +0000732 if (UsedArray.empty())
733 return;
Chris Lattner3def9ae2012-02-06 22:16:34 +0000734 llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size());
Mike Stump11289f42009-09-09 15:08:12 +0000735
736 llvm::GlobalVariable *GV =
737 new llvm::GlobalVariable(getModule(), ATy, false,
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000738 llvm::GlobalValue::AppendingLinkage,
Owen Anderson47034e12009-07-28 18:33:04 +0000739 llvm::ConstantArray::get(ATy, UsedArray),
Owen Andersonc10c8d32009-07-08 19:05:04 +0000740 "llvm.used");
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000741
742 GV->setSection("llvm.metadata");
743}
744
Douglas Gregorbc25ff42013-01-14 20:53:57 +0000745/// \brief Add link options implied by the given module, including modules
746/// it depends on, using a postorder walk.
747static void addLinkOptionsPostorder(llvm::LLVMContext &Context,
748 Module *Mod,
Daniel Dunbar69e47462013-01-17 01:35:06 +0000749 SmallVectorImpl<llvm::Value *> &Metadata,
Douglas Gregorbc25ff42013-01-14 20:53:57 +0000750 llvm::SmallPtrSet<Module *, 16> &Visited) {
751 // Import this module's parent.
752 if (Mod->Parent && Visited.insert(Mod->Parent)) {
753 addLinkOptionsPostorder(Context, Mod->Parent, Metadata, Visited);
754 }
755
756 // Import this module's dependencies.
757 for (unsigned I = Mod->Imports.size(); I > 0; --I) {
758 if (Visited.insert(Mod->Imports[I-1]))
759 addLinkOptionsPostorder(Context, Mod->Imports[I-1], Metadata, Visited);
760 }
761
762 // Add linker options to link against the libraries/frameworks
763 // described by this module.
764 for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) {
765 // FIXME: -lfoo is Unix-centric and -framework Foo is Darwin-centric.
766 // We need to know more about the linker to know how to encode these
767 // options propertly.
768
769 // Link against a framework.
770 if (Mod->LinkLibraries[I-1].IsFramework) {
771 llvm::Value *Args[2] = {
772 llvm::MDString::get(Context, "-framework"),
773 llvm::MDString::get(Context, Mod->LinkLibraries[I-1].Library)
774 };
775
776 Metadata.push_back(llvm::MDNode::get(Context, Args));
777 continue;
778 }
779
780 // Link against a library.
781 llvm::Value *OptString
782 = llvm::MDString::get(Context,
783 "-l" + Mod->LinkLibraries[I-1].Library);
784 Metadata.push_back(llvm::MDNode::get(Context, OptString));
785 }
786}
787
788void CodeGenModule::EmitModuleLinkOptions() {
789 // Collect the set of all of the modules we want to visit to emit link
790 // options, which is essentially the imported modules and all of their
791 // non-explicit child modules.
792 llvm::SetVector<clang::Module *> LinkModules;
793 llvm::SmallPtrSet<clang::Module *, 16> Visited;
794 SmallVector<clang::Module *, 16> Stack;
795
796 // Seed the stack with imported modules.
797 for (llvm::SetVector<clang::Module *>::iterator M = ImportedModules.begin(),
798 MEnd = ImportedModules.end();
799 M != MEnd; ++M) {
800 if (Visited.insert(*M))
801 Stack.push_back(*M);
802 }
803
804 // Find all of the modules to import, making a little effort to prune
805 // non-leaf modules.
806 while (!Stack.empty()) {
807 clang::Module *Mod = Stack.back();
808 Stack.pop_back();
809
810 bool AnyChildren = false;
811
812 // Visit the submodules of this module.
813 for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(),
814 SubEnd = Mod->submodule_end();
815 Sub != SubEnd; ++Sub) {
816 // Skip explicit children; they need to be explicitly imported to be
817 // linked against.
818 if ((*Sub)->IsExplicit)
819 continue;
820
821 if (Visited.insert(*Sub)) {
822 Stack.push_back(*Sub);
823 AnyChildren = true;
824 }
825 }
826
827 // We didn't find any children, so add this module to the list of
828 // modules to link against.
829 if (!AnyChildren) {
830 LinkModules.insert(Mod);
831 }
832 }
833
834 // Add link options for all of the imported modules in reverse topological
835 // order.
Daniel Dunbar69e47462013-01-17 01:35:06 +0000836 SmallVector<llvm::Value *, 16> MetadataArgs;
Douglas Gregorbc25ff42013-01-14 20:53:57 +0000837 Visited.clear();
838 for (llvm::SetVector<clang::Module *>::iterator M = LinkModules.begin(),
839 MEnd = LinkModules.end();
840 M != MEnd; ++M) {
841 if (Visited.insert(*M))
842 addLinkOptionsPostorder(getLLVMContext(), *M, MetadataArgs, Visited);
843 }
Daniel Dunbar69e47462013-01-17 01:35:06 +0000844 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
Douglas Gregorbc25ff42013-01-14 20:53:57 +0000845
Daniel Dunbar69e47462013-01-17 01:35:06 +0000846 // Add the linker options metadata flag.
847 getModule().addModuleFlag(llvm::Module::AppendUnique, "Linker Options",
848 llvm::MDNode::get(getLLVMContext(), MetadataArgs));
Douglas Gregorbc25ff42013-01-14 20:53:57 +0000849}
850
Daniel Dunbar08b26a02009-02-13 20:29:50 +0000851void CodeGenModule::EmitDeferred() {
Chris Lattner45470942009-03-21 09:44:56 +0000852 // Emit code for any potentially referenced deferred decls. Since a
853 // previously unused static decl may become used during the generation of code
Nick Lewycky26da4dd2011-07-18 05:26:13 +0000854 // for a static function, iterate until no changes are made.
Rafael Espindolae7113ca2010-03-10 02:19:29 +0000855
John McCall6bd2a892013-01-25 22:31:03 +0000856 while (true) {
Anders Carlsson11e51402010-04-17 20:15:18 +0000857 if (!DeferredVTables.empty()) {
John McCall6bd2a892013-01-25 22:31:03 +0000858 EmitDeferredVTables();
859
860 // Emitting a v-table doesn't directly cause more v-tables to
861 // become deferred, although it can cause functions to be
862 // emitted that then need those v-tables.
863 assert(DeferredVTables.empty());
Rafael Espindolae7113ca2010-03-10 02:19:29 +0000864 }
865
John McCall6bd2a892013-01-25 22:31:03 +0000866 // Stop if we're out of both deferred v-tables and deferred declarations.
867 if (DeferredDeclsToEmit.empty()) break;
868
Anders Carlssondae1abc2009-05-05 04:44:02 +0000869 GlobalDecl D = DeferredDeclsToEmit.back();
Chris Lattner45470942009-03-21 09:44:56 +0000870 DeferredDeclsToEmit.pop_back();
871
John McCallc2af9392010-05-27 01:45:30 +0000872 // Check to see if we've already emitted this. This is necessary
873 // for a couple of reasons: first, decls can end up in the
874 // deferred-decls queue multiple times, and second, decls can end
875 // up with definitions in unusual ways (e.g. by an extern inline
876 // function acquiring a strong function redefinition). Just
877 // ignore these cases.
878 //
879 // TODO: That said, looking this up multiple times is very wasteful.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000880 StringRef Name = getMangledName(D);
John McCall7ec50432010-03-19 23:29:14 +0000881 llvm::GlobalValue *CGRef = GetGlobalValue(Name);
Chris Lattner45470942009-03-21 09:44:56 +0000882 assert(CGRef && "Deferred decl wasn't referenced?");
Mike Stump11289f42009-09-09 15:08:12 +0000883
Chris Lattner45470942009-03-21 09:44:56 +0000884 if (!CGRef->isDeclaration())
885 continue;
Mike Stump11289f42009-09-09 15:08:12 +0000886
John McCallc2af9392010-05-27 01:45:30 +0000887 // GlobalAlias::isDeclaration() defers to the aliasee, but for our
888 // purposes an alias counts as a definition.
889 if (isa<llvm::GlobalAlias>(CGRef))
890 continue;
891
Chris Lattner45470942009-03-21 09:44:56 +0000892 // Otherwise, emit the definition and move on to the next one.
893 EmitGlobalDefinition(D);
894 }
Chris Lattnerbed31442007-05-28 01:07:47 +0000895}
Chris Lattner09153c02007-06-22 18:48:09 +0000896
Julien Lerouge5a6b6982011-09-09 22:41:49 +0000897void CodeGenModule::EmitGlobalAnnotations() {
898 if (Annotations.empty())
899 return;
900
901 // Create a new global variable for the ConstantStruct in the Module.
902 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
903 Annotations[0]->getType(), Annotations.size()), Annotations);
904 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(),
905 Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array,
906 "llvm.global.annotations");
907 gv->setSection(AnnotationSection);
908}
909
Dmitri Gribenkof8579502013-01-12 19:30:44 +0000910llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
Julien Lerouge5a6b6982011-09-09 22:41:49 +0000911 llvm::StringMap<llvm::Constant*>::iterator i = AnnotationStrings.find(Str);
912 if (i != AnnotationStrings.end())
913 return i->second;
914
915 // Not found yet, create a new global.
Chris Lattner9c818332012-02-05 02:30:40 +0000916 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
Julien Lerouge5a6b6982011-09-09 22:41:49 +0000917 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(),
918 true, llvm::GlobalValue::PrivateLinkage, s, ".str");
919 gv->setSection(AnnotationSection);
920 gv->setUnnamedAddr(true);
921 AnnotationStrings[Str] = gv;
922 return gv;
923}
924
925llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) {
926 SourceManager &SM = getContext().getSourceManager();
927 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
928 if (PLoc.isValid())
929 return EmitAnnotationString(PLoc.getFilename());
930 return EmitAnnotationString(SM.getBufferName(Loc));
931}
932
933llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
934 SourceManager &SM = getContext().getSourceManager();
935 PresumedLoc PLoc = SM.getPresumedLoc(L);
936 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
937 SM.getExpansionLineNumber(L);
938 return llvm::ConstantInt::get(Int32Ty, LineNo);
939}
940
Mike Stump11289f42009-09-09 15:08:12 +0000941llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
Nate Begemanfaae0812008-04-19 04:17:09 +0000942 const AnnotateAttr *AA,
Julien Lerouge5a6b6982011-09-09 22:41:49 +0000943 SourceLocation L) {
944 // Get the globals for file name, annotation, and the line number.
945 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
946 *UnitGV = EmitAnnotationUnit(L),
947 *LineNoCst = EmitAnnotationLineNo(L);
Nate Begemanfaae0812008-04-19 04:17:09 +0000948
Daniel Dunbar346892a2009-04-14 22:41:13 +0000949 // Create the ConstantStruct for the global annotation.
Nate Begemanfaae0812008-04-19 04:17:09 +0000950 llvm::Constant *Fields[4] = {
Julien Lerouge5a6b6982011-09-09 22:41:49 +0000951 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
952 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
953 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
954 LineNoCst
Nate Begemanfaae0812008-04-19 04:17:09 +0000955 };
Chris Lattnere64d7ba2011-06-20 04:01:35 +0000956 return llvm::ConstantStruct::getAnon(Fields);
Nate Begemanfaae0812008-04-19 04:17:09 +0000957}
958
Julien Lerouge5a6b6982011-09-09 22:41:49 +0000959void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
960 llvm::GlobalValue *GV) {
961 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
962 // Get the struct elements for these annotations.
963 for (specific_attr_iterator<AnnotateAttr>
964 ai = D->specific_attr_begin<AnnotateAttr>(),
965 ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai)
966 Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation()));
967}
968
Argyrios Kyrtzidisc0279a92010-07-27 22:37:14 +0000969bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
Argyrios Kyrtzidisc81af032010-07-29 18:15:58 +0000970 // Never defer when EmitAllDecls is specified.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000971 if (LangOpts.EmitAllDecls)
Daniel Dunbar6b8720e2009-02-13 21:18:01 +0000972 return false;
Daniel Dunbar9c426522008-07-29 23:18:29 +0000973
Argyrios Kyrtzidisc9049332010-07-29 20:08:05 +0000974 return !getContext().DeclMustBeEmitted(Global);
Daniel Dunbar6b8720e2009-02-13 21:18:01 +0000975}
976
Nico Webercf4ff5862012-10-11 10:13:44 +0000977llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor(
978 const CXXUuidofExpr* E) {
979 // Sema has verified that IIDSource has a __declspec(uuid()), and that its
980 // well-formed.
981 StringRef Uuid;
982 if (E->isTypeOperand())
983 Uuid = CXXUuidofExpr::GetUuidAttrOfType(E->getTypeOperand())->getGuid();
984 else {
985 // Special case: __uuidof(0) means an all-zero GUID.
986 Expr *Op = E->getExprOperand();
987 if (!Op->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
988 Uuid = CXXUuidofExpr::GetUuidAttrOfType(Op->getType())->getGuid();
989 else
990 Uuid = "00000000-0000-0000-0000-000000000000";
991 }
992 std::string Name = "__uuid_" + Uuid.str();
993
994 // Look for an existing global.
995 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
996 return GV;
997
998 llvm::Constant *Init = EmitUuidofInitializer(Uuid, E->getType());
999 assert(Init && "failed to initialize as constant");
1000
1001 // GUIDs are assumed to be 16 bytes, spread over 4-2-2-8 bytes. However, the
1002 // first field is declared as "long", which for many targets is 8 bytes.
1003 // Those architectures are not supported. (With the MS abi, long is always 4
1004 // bytes.)
1005 llvm::Type *GuidType = getTypes().ConvertType(E->getType());
1006 if (Init->getType() != GuidType) {
1007 DiagnosticsEngine &Diags = getDiags();
1008 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
1009 "__uuidof codegen is not supported on this architecture");
1010 Diags.Report(E->getExprLoc(), DiagID) << E->getSourceRange();
1011 Init = llvm::UndefValue::get(GuidType);
1012 }
1013
1014 llvm::GlobalVariable *GV = new llvm::GlobalVariable(getModule(), GuidType,
1015 /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, Init, Name);
1016 GV->setUnnamedAddr(true);
1017 return GV;
1018}
1019
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001020llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
1021 const AliasAttr *AA = VD->getAttr<AliasAttr>();
1022 assert(AA && "No alias?");
1023
Chris Lattner2192fe52011-07-18 04:24:23 +00001024 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001025
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001026 // See if there is already something with the target's name in the module.
John McCall7ec50432010-03-19 23:29:14 +00001027 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
Joerg Sonnenbergerde78bba2012-10-16 17:45:27 +00001028 if (Entry) {
1029 unsigned AS = getContext().getTargetAddressSpace(VD->getType());
1030 return llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
1031 }
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001032
1033 llvm::Constant *Aliasee;
1034 if (isa<llvm::FunctionType>(DeclTy))
Alex Rosenbergba036122012-10-05 23:12:53 +00001035 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
1036 GlobalDecl(cast<FunctionDecl>(VD)),
Anders Carlsson3c239482011-02-05 04:35:53 +00001037 /*ForVTable=*/false);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001038 else
John McCall7ec50432010-03-19 23:29:14 +00001039 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001040 llvm::PointerType::getUnqual(DeclTy), 0);
Joerg Sonnenbergerde78bba2012-10-16 17:45:27 +00001041
1042 llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee);
1043 F->setLinkage(llvm::Function::ExternalWeakLinkage);
1044 WeakRefReferences.insert(F);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001045
1046 return Aliasee;
1047}
1048
Chris Lattnere0be0df2009-05-12 21:21:08 +00001049void CodeGenModule::EmitGlobal(GlobalDecl GD) {
Anders Carlsson38988d72009-09-10 23:38:47 +00001050 const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
Mike Stump11289f42009-09-09 15:08:12 +00001051
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001052 // Weak references don't produce any output by themselves.
1053 if (Global->hasAttr<WeakRefAttr>())
1054 return;
1055
Chris Lattner54041692009-03-22 21:47:11 +00001056 // If this is an alias definition (which otherwise looks like a declaration)
1057 // emit it now.
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00001058 if (Global->hasAttr<AliasAttr>())
John McCall7ec50432010-03-19 23:29:14 +00001059 return EmitAliasDefinition(GD);
Daniel Dunbar0beedc12008-09-08 23:44:31 +00001060
Peter Collingbournea9455ec2011-10-06 18:29:46 +00001061 // If this is CUDA, be selective about which declarations we emit.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001062 if (LangOpts.CUDA) {
Peter Collingbournea9455ec2011-10-06 18:29:46 +00001063 if (CodeGenOpts.CUDAIsDevice) {
1064 if (!Global->hasAttr<CUDADeviceAttr>() &&
1065 !Global->hasAttr<CUDAGlobalAttr>() &&
1066 !Global->hasAttr<CUDAConstantAttr>() &&
1067 !Global->hasAttr<CUDASharedAttr>())
1068 return;
1069 } else {
1070 if (!Global->hasAttr<CUDAHostAttr>() && (
1071 Global->hasAttr<CUDADeviceAttr>() ||
1072 Global->hasAttr<CUDAConstantAttr>() ||
1073 Global->hasAttr<CUDASharedAttr>()))
1074 return;
1075 }
1076 }
1077
Chris Lattner45470942009-03-21 09:44:56 +00001078 // Ignore declarations, they will be emitted on their first use.
Daniel Dunbar4e004ed2009-03-19 08:27:24 +00001079 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
Daniel Dunbar6b8720e2009-02-13 21:18:01 +00001080 // Forward declarations are emitted lazily on first use.
Nick Lewycky26da4dd2011-07-18 05:26:13 +00001081 if (!FD->doesThisDeclarationHaveABody()) {
1082 if (!FD->doesDeclarationForceExternallyVisibleDefinition())
1083 return;
1084
1085 const FunctionDecl *InlineDefinition = 0;
1086 FD->getBody(InlineDefinition);
1087
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001088 StringRef MangledName = getMangledName(GD);
Benjamin Kramere894e092012-03-24 18:22:12 +00001089 DeferredDecls.erase(MangledName);
Nick Lewycky26da4dd2011-07-18 05:26:13 +00001090 EmitGlobalDefinition(InlineDefinition);
Daniel Dunbar6b8720e2009-02-13 21:18:01 +00001091 return;
Nick Lewycky26da4dd2011-07-18 05:26:13 +00001092 }
Daniel Dunbar08b26a02009-02-13 20:29:50 +00001093 } else {
1094 const VarDecl *VD = cast<VarDecl>(Global);
Daniel Dunbar9c426522008-07-29 23:18:29 +00001095 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
1096
Douglas Gregor61f6db52010-02-06 05:15:45 +00001097 if (VD->isThisDeclarationADefinition() != VarDecl::Definition)
Douglas Gregorbeecd582009-04-21 17:11:58 +00001098 return;
Nate Begeman8e8d4982008-04-20 06:29:50 +00001099 }
1100
Chris Lattner45470942009-03-21 09:44:56 +00001101 // Defer code generation when possible if this is a static definition, inline
1102 // function etc. These we only want to emit if they are used.
Chris Lattner7a4a29f2010-04-13 17:39:09 +00001103 if (!MayDeferGeneration(Global)) {
1104 // Emit the definition if it can't be deferred.
1105 EmitGlobalDefinition(GD);
Daniel Dunbar9c426522008-07-29 23:18:29 +00001106 return;
1107 }
John McCall70013b62010-07-15 23:40:35 +00001108
1109 // If we're deferring emission of a C++ variable with an
1110 // initializer, remember the order in which it appeared in the file.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001111 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
John McCall70013b62010-07-15 23:40:35 +00001112 cast<VarDecl>(Global)->hasInit()) {
1113 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
1114 CXXGlobalInits.push_back(0);
1115 }
Chris Lattner7a4a29f2010-04-13 17:39:09 +00001116
1117 // If the value has already been used, add it directly to the
1118 // DeferredDeclsToEmit list.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001119 StringRef MangledName = getMangledName(GD);
Chris Lattner7a4a29f2010-04-13 17:39:09 +00001120 if (GetGlobalValue(MangledName))
1121 DeferredDeclsToEmit.push_back(GD);
1122 else {
1123 // Otherwise, remember that we saw a deferred decl with this name. The
1124 // first use of the mangled name will cause it to move into
1125 // DeferredDeclsToEmit.
1126 DeferredDecls[MangledName] = GD;
1127 }
Nate Begeman8e8d4982008-04-20 06:29:50 +00001128}
1129
Rafael Espindolac5941352011-10-26 20:41:06 +00001130namespace {
1131 struct FunctionIsDirectlyRecursive :
1132 public RecursiveASTVisitor<FunctionIsDirectlyRecursive> {
1133 const StringRef Name;
Rafael Espindola4fdc1752011-12-19 14:41:01 +00001134 const Builtin::Context &BI;
Rafael Espindolac5941352011-10-26 20:41:06 +00001135 bool Result;
Rafael Espindola4fdc1752011-12-19 14:41:01 +00001136 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) :
1137 Name(N), BI(C), Result(false) {
Rafael Espindolac5941352011-10-26 20:41:06 +00001138 }
1139 typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base;
1140
1141 bool TraverseCallExpr(CallExpr *E) {
Rafael Espindola4fdc1752011-12-19 14:41:01 +00001142 const FunctionDecl *FD = E->getDirectCallee();
1143 if (!FD)
Rafael Espindolac5941352011-10-26 20:41:06 +00001144 return true;
Rafael Espindola4fdc1752011-12-19 14:41:01 +00001145 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1146 if (Attr && Name == Attr->getLabel()) {
1147 Result = true;
1148 return false;
1149 }
1150 unsigned BuiltinID = FD->getBuiltinID();
1151 if (!BuiltinID)
Rafael Espindolac5941352011-10-26 20:41:06 +00001152 return true;
Nick Lewycky9ed5b152012-01-18 03:41:19 +00001153 StringRef BuiltinName = BI.GetName(BuiltinID);
1154 if (BuiltinName.startswith("__builtin_") &&
1155 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
Rafael Espindolac5941352011-10-26 20:41:06 +00001156 Result = true;
1157 return false;
1158 }
1159 return true;
1160 }
1161 };
1162}
1163
Rafael Espindola4fdc1752011-12-19 14:41:01 +00001164// isTriviallyRecursive - Check if this function calls another
1165// decl that, because of the asm attribute or the other decl being a builtin,
1166// ends up pointing to itself.
Rafael Espindolac5941352011-10-26 20:41:06 +00001167bool
Rafael Espindola4fdc1752011-12-19 14:41:01 +00001168CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
1169 StringRef Name;
1170 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
Nick Lewycky72cd2292012-01-18 01:50:13 +00001171 // asm labels are a special kind of mangling we have to support.
Rafael Espindola4fdc1752011-12-19 14:41:01 +00001172 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1173 if (!Attr)
1174 return false;
1175 Name = Attr->getLabel();
1176 } else {
1177 Name = FD->getName();
1178 }
Rafael Espindolac5941352011-10-26 20:41:06 +00001179
Rafael Espindola4fdc1752011-12-19 14:41:01 +00001180 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
1181 Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD));
Rafael Espindolac5941352011-10-26 20:41:06 +00001182 return Walker.Result;
1183}
1184
1185bool
1186CodeGenModule::shouldEmitFunction(const FunctionDecl *F) {
1187 if (getFunctionLinkage(F) != llvm::Function::AvailableExternallyLinkage)
1188 return true;
Rafael Espindolafffc1ce2011-10-28 20:43:56 +00001189 if (CodeGenOpts.OptimizationLevel == 0 &&
Michael J. Spencerf97bd8c2012-06-18 07:00:48 +00001190 !F->hasAttr<AlwaysInlineAttr>() && !F->hasAttr<ForceInlineAttr>())
Rafael Espindolac5941352011-10-26 20:41:06 +00001191 return false;
1192 // PR9614. Avoid cases where the source code is lying to us. An available
1193 // externally function should have an equivalent function somewhere else,
1194 // but a function that calls itself is clearly not equivalent to the real
1195 // implementation.
1196 // This happens in glibc's btowc and in some configure checks.
Rafael Espindola4fdc1752011-12-19 14:41:01 +00001197 return !isTriviallyRecursive(F);
Rafael Espindolac5941352011-10-26 20:41:06 +00001198}
1199
Chris Lattnere0be0df2009-05-12 21:21:08 +00001200void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
Anders Carlsson38988d72009-09-10 23:38:47 +00001201 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Mike Stump11289f42009-09-09 15:08:12 +00001202
Dan Gohman145f3f12010-04-19 16:39:44 +00001203 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
Anders Carlsson29295bf2009-10-27 14:32:27 +00001204 Context.getSourceManager(),
1205 "Generating code for declaration");
1206
Douglas Gregora700f682010-07-13 06:02:28 +00001207 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
1208 // At -O0, don't generate IR for functions with available_externally
1209 // linkage.
Rafael Espindolac5941352011-10-26 20:41:06 +00001210 if (!shouldEmitFunction(Function))
Douglas Gregora700f682010-07-13 06:02:28 +00001211 return;
Anders Carlssonaf82f632010-03-23 04:31:31 +00001212
Douglas Gregora700f682010-07-13 06:02:28 +00001213 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
Eli Friedman49a94b12011-05-06 17:27:27 +00001214 // Make sure to emit the definition(s) before we emit the thunks.
1215 // This is necessary for the generation of certain thunks.
1216 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
1217 EmitCXXConstructor(CD, GD.getCtorType());
1218 else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method))
1219 EmitCXXDestructor(DD, GD.getDtorType());
1220 else
1221 EmitGlobalFunctionDefinition(GD);
1222
Douglas Gregora700f682010-07-13 06:02:28 +00001223 if (Method->isVirtual())
1224 getVTables().EmitThunks(GD);
1225
Eli Friedman49a94b12011-05-06 17:27:27 +00001226 return;
Douglas Gregora700f682010-07-13 06:02:28 +00001227 }
Chris Lattnerd8d760c2010-04-13 17:57:11 +00001228
Chris Lattnerd8d760c2010-04-13 17:57:11 +00001229 return EmitGlobalFunctionDefinition(GD);
Douglas Gregora700f682010-07-13 06:02:28 +00001230 }
Chris Lattnerd8d760c2010-04-13 17:57:11 +00001231
1232 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
1233 return EmitGlobalVarDefinition(VD);
Chris Lattner7a4a29f2010-04-13 17:39:09 +00001234
David Blaikie83d382b2011-09-23 05:06:16 +00001235 llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
Daniel Dunbar9c426522008-07-29 23:18:29 +00001236}
1237
Chris Lattnerd4808922009-03-22 21:03:39 +00001238/// GetOrCreateLLVMFunction - If the specified mangled name is not in the
1239/// module, create and return an llvm Function with the specified type. If there
1240/// is something in the module with the specified name, return it potentially
1241/// bitcasted to the right type.
1242///
1243/// If D is non-null, it specifies a decl that correspond to this. This is used
1244/// to set the attributes on the function when it is first created.
John McCall7ec50432010-03-19 23:29:14 +00001245llvm::Constant *
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001246CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName,
Chris Lattner2192fe52011-07-18 04:24:23 +00001247 llvm::Type *Ty,
John McCall31168b02011-06-15 23:02:42 +00001248 GlobalDecl D, bool ForVTable,
Bill Wendling8594fcb2013-01-31 00:30:05 +00001249 llvm::AttributeSet ExtraAttrs) {
Chris Lattnera85d68e2009-03-21 09:25:43 +00001250 // Lookup the entry, lazily creating it if necessary.
John McCall7ec50432010-03-19 23:29:14 +00001251 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattnera85d68e2009-03-21 09:25:43 +00001252 if (Entry) {
Benjamin Kramerfc6eb7d2012-08-22 15:37:55 +00001253 if (WeakRefReferences.erase(Entry)) {
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001254 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl());
1255 if (FD && !FD->hasAttr<WeakAttr>())
Anders Carlssonaf82f632010-03-23 04:31:31 +00001256 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001257 }
1258
Chris Lattnera85d68e2009-03-21 09:25:43 +00001259 if (Entry->getType()->getElementType() == Ty)
1260 return Entry;
Mike Stump11289f42009-09-09 15:08:12 +00001261
Chris Lattnera85d68e2009-03-21 09:25:43 +00001262 // Make sure the result is of the correct type.
Chris Lattnera5f58b02011-07-09 17:41:47 +00001263 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
Chris Lattnera85d68e2009-03-21 09:25:43 +00001264 }
Mike Stump11289f42009-09-09 15:08:12 +00001265
Eli Friedmancc522d92009-11-09 05:07:37 +00001266 // This function doesn't have a complete type (for example, the return
1267 // type is an incomplete struct). Use a fake type instead, and make
1268 // sure not to try to set attributes.
1269 bool IsIncompleteFunction = false;
John McCalld06fb862010-04-28 00:00:30 +00001270
Chris Lattner2192fe52011-07-18 04:24:23 +00001271 llvm::FunctionType *FTy;
John McCalld06fb862010-04-28 00:00:30 +00001272 if (isa<llvm::FunctionType>(Ty)) {
1273 FTy = cast<llvm::FunctionType>(Ty);
1274 } else {
John McCall9dc0db22011-05-15 01:53:33 +00001275 FTy = llvm::FunctionType::get(VoidTy, false);
Eli Friedmancc522d92009-11-09 05:07:37 +00001276 IsIncompleteFunction = true;
1277 }
Chris Lattner5c740f12010-06-30 19:14:05 +00001278
John McCalld06fb862010-04-28 00:00:30 +00001279 llvm::Function *F = llvm::Function::Create(FTy,
Eli Friedmancc522d92009-11-09 05:07:37 +00001280 llvm::Function::ExternalLinkage,
John McCall7ec50432010-03-19 23:29:14 +00001281 MangledName, &getModule());
1282 assert(F->getName() == MangledName && "name was uniqued!");
Eli Friedmancc522d92009-11-09 05:07:37 +00001283 if (D.getDecl())
Anders Carlsson6710c532010-02-06 02:44:09 +00001284 SetFunctionAttributes(D, F, IsIncompleteFunction);
Bill Wendling8594fcb2013-01-31 00:30:05 +00001285 if (ExtraAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex)) {
1286 llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeSet::FunctionIndex);
Bill Wendling9a677922013-01-23 00:21:06 +00001287 F->addAttributes(llvm::AttributeSet::FunctionIndex,
1288 llvm::AttributeSet::get(VMContext,
1289 llvm::AttributeSet::FunctionIndex,
1290 B));
1291 }
Eli Friedmancc522d92009-11-09 05:07:37 +00001292
Chris Lattner45470942009-03-21 09:44:56 +00001293 // This is the first use or definition of a mangled name. If there is a
1294 // deferred decl with this name, remember that we need to emit it at the end
1295 // of the file.
John McCall7ec50432010-03-19 23:29:14 +00001296 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner45470942009-03-21 09:44:56 +00001297 if (DDI != DeferredDecls.end()) {
1298 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1299 // list, and remove it from DeferredDecls (since we don't need it anymore).
1300 DeferredDeclsToEmit.push_back(DDI->second);
1301 DeferredDecls.erase(DDI);
John McCall357d0f32010-12-15 04:00:32 +00001302
1303 // Otherwise, there are cases we have to worry about where we're
1304 // using a declaration for which we must emit a definition but where
1305 // we might not find a top-level definition:
1306 // - member functions defined inline in their classes
1307 // - friend functions defined inline in some class
1308 // - special member functions with implicit definitions
1309 // If we ever change our AST traversal to walk into class methods,
1310 // this will be unnecessary.
Anders Carlsson3c239482011-02-05 04:35:53 +00001311 //
1312 // We also don't emit a definition for a function if it's going to be an entry
1313 // in a vtable, unless it's already marked as used.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001314 } else if (getLangOpts().CPlusPlus && D.getDecl()) {
John McCall357d0f32010-12-15 04:00:32 +00001315 // Look for a declaration that's lexically in a record.
1316 const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl());
Eli Friedmanc9f43942012-07-02 21:05:30 +00001317 FD = FD->getMostRecentDecl();
John McCall357d0f32010-12-15 04:00:32 +00001318 do {
1319 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
Anders Carlsson3c239482011-02-05 04:35:53 +00001320 if (FD->isImplicit() && !ForVTable) {
John McCall357d0f32010-12-15 04:00:32 +00001321 assert(FD->isUsed() && "Sema didn't mark implicit function as used!");
Douglas Gregor25756312011-02-09 02:03:05 +00001322 DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
John McCall357d0f32010-12-15 04:00:32 +00001323 break;
Alexis Hunt4a8ea102011-05-06 20:44:56 +00001324 } else if (FD->doesThisDeclarationHaveABody()) {
Douglas Gregor25756312011-02-09 02:03:05 +00001325 DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
John McCall357d0f32010-12-15 04:00:32 +00001326 break;
1327 }
Rafael Espindola70e040d2010-03-02 21:28:26 +00001328 }
Douglas Gregorec9fd132012-01-14 16:38:05 +00001329 FD = FD->getPreviousDecl();
John McCall357d0f32010-12-15 04:00:32 +00001330 } while (FD);
Chris Lattner45470942009-03-21 09:44:56 +00001331 }
Mike Stump11289f42009-09-09 15:08:12 +00001332
John McCalld06fb862010-04-28 00:00:30 +00001333 // Make sure the result is of the requested type.
1334 if (!IsIncompleteFunction) {
1335 assert(F->getType()->getElementType() == Ty);
1336 return F;
1337 }
1338
Chris Lattnera5f58b02011-07-09 17:41:47 +00001339 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
John McCalld06fb862010-04-28 00:00:30 +00001340 return llvm::ConstantExpr::getBitCast(F, PTy);
Chris Lattnera85d68e2009-03-21 09:25:43 +00001341}
1342
Chris Lattnerd4808922009-03-22 21:03:39 +00001343/// GetAddrOfFunction - Return the address of the given function. If Ty is
1344/// non-null, then this function will use the specified type if it has to
1345/// create it (this occurs when we see a definition of the function).
Chris Lattnere0be0df2009-05-12 21:21:08 +00001346llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
Chris Lattner2192fe52011-07-18 04:24:23 +00001347 llvm::Type *Ty,
Anders Carlsson3c239482011-02-05 04:35:53 +00001348 bool ForVTable) {
Chris Lattnerd4808922009-03-22 21:03:39 +00001349 // If there was no specific requested type, just convert it now.
1350 if (!Ty)
Anders Carlsson38988d72009-09-10 23:38:47 +00001351 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
Chris Lattner5c740f12010-06-30 19:14:05 +00001352
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001353 StringRef MangledName = getMangledName(GD);
Anders Carlsson3c239482011-02-05 04:35:53 +00001354 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable);
Chris Lattnerd4808922009-03-22 21:03:39 +00001355}
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001356
Chris Lattnerd4808922009-03-22 21:03:39 +00001357/// CreateRuntimeFunction - Create a new runtime function with the specified
1358/// type and name.
1359llvm::Constant *
Chris Lattner2192fe52011-07-18 04:24:23 +00001360CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001361 StringRef Name,
Bill Wendling8594fcb2013-01-31 00:30:05 +00001362 llvm::AttributeSet ExtraAttrs) {
John McCall882987f2013-02-28 19:01:20 +00001363 llvm::Constant *C
1364 = GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
1365 ExtraAttrs);
1366 if (llvm::Function *F = dyn_cast<llvm::Function>(C))
1367 if (F->empty())
1368 F->setCallingConv(getRuntimeCC());
1369 return C;
Chris Lattnerd4808922009-03-22 21:03:39 +00001370}
Daniel Dunbar9c426522008-07-29 23:18:29 +00001371
Richard Smithe070fd22012-02-17 06:48:11 +00001372/// isTypeConstant - Determine whether an object of this type can be emitted
1373/// as a constant.
1374///
1375/// If ExcludeCtor is true, the duration when the object's constructor runs
1376/// will not be considered. The caller will need to verify that the object is
1377/// not written to during its construction.
1378bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
1379 if (!Ty.isConstant(Context) && !Ty->isReferenceType())
Eli Friedmanb095e152009-12-11 21:23:03 +00001380 return false;
Richard Smithe070fd22012-02-17 06:48:11 +00001381
David Blaikiebbafb8a2012-03-11 07:00:24 +00001382 if (Context.getLangOpts().CPlusPlus) {
Richard Smithe070fd22012-02-17 06:48:11 +00001383 if (const CXXRecordDecl *Record
1384 = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
1385 return ExcludeCtor && !Record->hasMutableFields() &&
1386 Record->hasTrivialDestructor();
Eli Friedmanb095e152009-12-11 21:23:03 +00001387 }
Richard Smithe070fd22012-02-17 06:48:11 +00001388
Eli Friedmanb095e152009-12-11 21:23:03 +00001389 return true;
1390}
1391
Chris Lattnerd4808922009-03-22 21:03:39 +00001392/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
1393/// create and return an llvm GlobalVariable with the specified type. If there
1394/// is something in the module with the specified name, return it potentially
1395/// bitcasted to the right type.
1396///
1397/// If D is non-null, it specifies a decl that correspond to this. This is used
1398/// to set the attributes on the global when it is first created.
John McCall7ec50432010-03-19 23:29:14 +00001399llvm::Constant *
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001400CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
Chris Lattner2192fe52011-07-18 04:24:23 +00001401 llvm::PointerType *Ty,
Rafael Espindolad661a852011-01-18 21:07:57 +00001402 const VarDecl *D,
1403 bool UnnamedAddr) {
Daniel Dunbar829e9882008-08-05 23:31:02 +00001404 // Lookup the entry, lazily creating it if necessary.
John McCall7ec50432010-03-19 23:29:14 +00001405 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner3bfce182009-03-21 08:03:33 +00001406 if (Entry) {
Benjamin Kramerfc6eb7d2012-08-22 15:37:55 +00001407 if (WeakRefReferences.erase(Entry)) {
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001408 if (D && !D->hasAttr<WeakAttr>())
Anders Carlssonaf82f632010-03-23 04:31:31 +00001409 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola2e42fec2010-03-04 18:17:24 +00001410 }
1411
Rafael Espindolad661a852011-01-18 21:07:57 +00001412 if (UnnamedAddr)
1413 Entry->setUnnamedAddr(true);
1414
Chris Lattnerd4808922009-03-22 21:03:39 +00001415 if (Entry->getType() == Ty)
Chris Lattner149927c2009-03-21 09:16:30 +00001416 return Entry;
Mike Stump11289f42009-09-09 15:08:12 +00001417
Chris Lattner3bfce182009-03-21 08:03:33 +00001418 // Make sure the result is of the correct type.
Owen Andersonade90fd2009-07-29 18:54:39 +00001419 return llvm::ConstantExpr::getBitCast(Entry, Ty);
Daniel Dunbardec798b2009-01-13 02:25:00 +00001420 }
Mike Stump11289f42009-09-09 15:08:12 +00001421
Chris Lattner45470942009-03-21 09:44:56 +00001422 // This is the first use or definition of a mangled name. If there is a
1423 // deferred decl with this name, remember that we need to emit it at the end
1424 // of the file.
John McCall7ec50432010-03-19 23:29:14 +00001425 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner45470942009-03-21 09:44:56 +00001426 if (DDI != DeferredDecls.end()) {
1427 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1428 // list, and remove it from DeferredDecls (since we don't need it anymore).
1429 DeferredDeclsToEmit.push_back(DDI->second);
1430 DeferredDecls.erase(DDI);
1431 }
Mike Stump11289f42009-09-09 15:08:12 +00001432
Peter Collingbournef44bdf92012-05-20 21:08:35 +00001433 unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace());
Mike Stump11289f42009-09-09 15:08:12 +00001434 llvm::GlobalVariable *GV =
1435 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
Chris Lattner3bfce182009-03-21 08:03:33 +00001436 llvm::GlobalValue::ExternalLinkage,
John McCall7ec50432010-03-19 23:29:14 +00001437 0, MangledName, 0,
Hans Wennborgd3b01bc2012-06-23 11:51:46 +00001438 llvm::GlobalVariable::NotThreadLocal, AddrSpace);
Chris Lattner3bfce182009-03-21 08:03:33 +00001439
1440 // Handle things which are present even on external declarations.
Chris Lattnerd4808922009-03-22 21:03:39 +00001441 if (D) {
Mike Stump18bb9282009-05-16 07:57:57 +00001442 // FIXME: This code is overly simple and should be merged with other global
1443 // handling.
Richard Smithe070fd22012-02-17 06:48:11 +00001444 GV->setConstant(isTypeConstant(D->getType(), false));
Chris Lattner3bfce182009-03-21 08:03:33 +00001445
John McCall37bb6c92010-10-29 22:22:43 +00001446 // Set linkage and visibility in case we never see a definition.
Rafael Espindolaa8fbdab2013-02-27 02:15:29 +00001447 LinkageInfo LV = D->getLinkageAndVisibility();
Rafael Espindola4a5da442013-02-27 02:56:45 +00001448 if (LV.getLinkage() != ExternalLinkage) {
John McCall83779672011-02-19 02:53:41 +00001449 // Don't set internal linkage on declarations.
John McCall37bb6c92010-10-29 22:22:43 +00001450 } else {
1451 if (D->hasAttr<DLLImportAttr>())
1452 GV->setLinkage(llvm::GlobalValue::DLLImportLinkage);
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00001453 else if (D->hasAttr<WeakAttr>() || D->isWeakImported())
John McCall37bb6c92010-10-29 22:22:43 +00001454 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Chris Lattner3bfce182009-03-21 08:03:33 +00001455
John McCallc273f242010-10-30 11:50:40 +00001456 // Set visibility on a declaration only if it's explicit.
Rafael Espindola4a5da442013-02-27 02:56:45 +00001457 if (LV.isVisibilityExplicit())
1458 GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
John McCall37bb6c92010-10-29 22:22:43 +00001459 }
Eli Friedman4f856742009-04-19 21:05:03 +00001460
Hans Wennborgf60f6af2012-06-28 08:01:44 +00001461 if (D->isThreadSpecified())
1462 setTLSMode(GV, *D);
Chris Lattnerd4808922009-03-22 21:03:39 +00001463 }
Mike Stump11289f42009-09-09 15:08:12 +00001464
Peter Collingbournef44bdf92012-05-20 21:08:35 +00001465 if (AddrSpace != Ty->getAddressSpace())
1466 return llvm::ConstantExpr::getBitCast(GV, Ty);
1467 else
1468 return GV;
Daniel Dunbar9c426522008-07-29 23:18:29 +00001469}
1470
Chris Lattnerd4808922009-03-22 21:03:39 +00001471
Anders Carlssonda80af32011-01-29 18:20:20 +00001472llvm::GlobalVariable *
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001473CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name,
Chris Lattner2192fe52011-07-18 04:24:23 +00001474 llvm::Type *Ty,
Anders Carlssonda80af32011-01-29 18:20:20 +00001475 llvm::GlobalValue::LinkageTypes Linkage) {
1476 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
1477 llvm::GlobalVariable *OldGV = 0;
1478
1479
1480 if (GV) {
1481 // Check if the variable has the right type.
1482 if (GV->getType()->getElementType() == Ty)
1483 return GV;
1484
1485 // Because C++ name mangling, the only way we can end up with an already
1486 // existing global with the same name is if it has been declared extern "C".
Nico Webercf4ff5862012-10-11 10:13:44 +00001487 assert(GV->isDeclaration() && "Declaration has wrong type!");
Anders Carlssonda80af32011-01-29 18:20:20 +00001488 OldGV = GV;
1489 }
1490
1491 // Create a new variable.
1492 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
1493 Linkage, 0, Name);
1494
1495 if (OldGV) {
1496 // Replace occurrences of the old variable if needed.
1497 GV->takeName(OldGV);
1498
1499 if (!OldGV->use_empty()) {
1500 llvm::Constant *NewPtrForOldDecl =
1501 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
1502 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
1503 }
1504
1505 OldGV->eraseFromParent();
1506 }
1507
1508 return GV;
1509}
1510
Chris Lattnerd4808922009-03-22 21:03:39 +00001511/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
1512/// given global variable. If Ty is non-null and if the global doesn't exist,
Eric Christopher365e3092012-04-16 23:55:04 +00001513/// then it will be created with the specified type instead of whatever the
Chris Lattnerd4808922009-03-22 21:03:39 +00001514/// normal requested type would be.
1515llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
Chris Lattner2192fe52011-07-18 04:24:23 +00001516 llvm::Type *Ty) {
Chris Lattnerd4808922009-03-22 21:03:39 +00001517 assert(D->hasGlobalStorage() && "Not a global variable");
1518 QualType ASTTy = D->getType();
1519 if (Ty == 0)
1520 Ty = getTypes().ConvertTypeForMem(ASTTy);
Mike Stump11289f42009-09-09 15:08:12 +00001521
Chris Lattner2192fe52011-07-18 04:24:23 +00001522 llvm::PointerType *PTy =
Peter Collingbourne599cb8e2011-03-18 22:38:29 +00001523 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
John McCall7ec50432010-03-19 23:29:14 +00001524
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001525 StringRef MangledName = getMangledName(D);
John McCall7ec50432010-03-19 23:29:14 +00001526 return GetOrCreateLLVMGlobal(MangledName, PTy, D);
Chris Lattnerd4808922009-03-22 21:03:39 +00001527}
1528
1529/// CreateRuntimeVariable - Create a new runtime global variable with the
1530/// specified type and name.
1531llvm::Constant *
Chris Lattner2192fe52011-07-18 04:24:23 +00001532CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001533 StringRef Name) {
John McCall31996342011-04-07 08:22:57 +00001534 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0,
Rafael Espindolad661a852011-01-18 21:07:57 +00001535 true);
Chris Lattnerd4808922009-03-22 21:03:39 +00001536}
1537
Daniel Dunbar7dd749e2009-04-15 22:08:45 +00001538void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1539 assert(!D->getInit() && "Cannot emit definite definitions here!");
1540
Douglas Gregorfa9ab532009-04-21 19:28:58 +00001541 if (MayDeferGeneration(D)) {
1542 // If we have not seen a reference to this variable yet, place it
1543 // into the deferred declarations table to be emitted if needed
1544 // later.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001545 StringRef MangledName = getMangledName(D);
John McCall7ec50432010-03-19 23:29:14 +00001546 if (!GetGlobalValue(MangledName)) {
Anders Carlssonecf9bf02009-09-10 23:43:36 +00001547 DeferredDecls[MangledName] = D;
Daniel Dunbar7dd749e2009-04-15 22:08:45 +00001548 return;
Douglas Gregorfa9ab532009-04-21 19:28:58 +00001549 }
1550 }
1551
1552 // The tentative definition is the only definition.
Daniel Dunbar7dd749e2009-04-15 22:08:45 +00001553 EmitGlobalVarDefinition(D);
1554}
1555
Chris Lattner2192fe52011-07-18 04:24:23 +00001556CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
Ken Dyck9a648692011-01-18 02:01:14 +00001557 return Context.toCharUnitsFromBits(
Micah Villmowdd31ca12012-10-08 16:25:52 +00001558 TheDataLayout.getTypeStoreSizeInBits(Ty));
Ken Dyck98ca7942010-01-26 13:48:07 +00001559}
1560
Sebastian Redl4a7eab22012-02-25 20:51:20 +00001561llvm::Constant *
1562CodeGenModule::MaybeEmitGlobalStdInitializerListInitializer(const VarDecl *D,
1563 const Expr *rawInit) {
1564 ArrayRef<ExprWithCleanups::CleanupObject> cleanups;
1565 if (const ExprWithCleanups *withCleanups =
1566 dyn_cast<ExprWithCleanups>(rawInit)) {
1567 cleanups = withCleanups->getObjects();
1568 rawInit = withCleanups->getSubExpr();
1569 }
1570
1571 const InitListExpr *init = dyn_cast<InitListExpr>(rawInit);
1572 if (!init || !init->initializesStdInitializerList() ||
1573 init->getNumInits() == 0)
1574 return 0;
1575
1576 ASTContext &ctx = getContext();
Sebastian Redl4a7eab22012-02-25 20:51:20 +00001577 unsigned numInits = init->getNumInits();
Sebastian Redla235e2d2012-02-27 23:20:01 +00001578 // FIXME: This check is here because we would otherwise silently miscompile
1579 // nested global std::initializer_lists. Better would be to have a real
1580 // implementation.
1581 for (unsigned i = 0; i < numInits; ++i) {
1582 const InitListExpr *inner = dyn_cast<InitListExpr>(init->getInit(i));
1583 if (inner && inner->initializesStdInitializerList()) {
1584 ErrorUnsupported(inner, "nested global std::initializer_list");
1585 return 0;
1586 }
1587 }
1588
1589 // Synthesize a fake VarDecl for the array and initialize that.
Sebastian Redl4a7eab22012-02-25 20:51:20 +00001590 QualType elementType = init->getInit(0)->getType();
1591 llvm::APInt numElements(ctx.getTypeSize(ctx.getSizeType()), numInits);
1592 QualType arrayType = ctx.getConstantArrayType(elementType, numElements,
1593 ArrayType::Normal, 0);
1594
1595 IdentifierInfo *name = &ctx.Idents.get(D->getNameAsString() + "__initlist");
1596 TypeSourceInfo *sourceInfo = ctx.getTrivialTypeSourceInfo(
1597 arrayType, D->getLocation());
1598 VarDecl *backingArray = VarDecl::Create(ctx, const_cast<DeclContext*>(
1599 D->getDeclContext()),
1600 D->getLocStart(), D->getLocation(),
1601 name, arrayType, sourceInfo,
1602 SC_Static, SC_Static);
1603
1604 // Now clone the InitListExpr to initialize the array instead.
1605 // Incredible hack: we want to use the existing InitListExpr here, so we need
1606 // to tell it that it no longer initializes a std::initializer_list.
Benjamin Kramerc215e762012-08-24 11:54:20 +00001607 ArrayRef<Expr*> Inits(const_cast<InitListExpr*>(init)->getInits(),
1608 init->getNumInits());
1609 Expr *arrayInit = new (ctx) InitListExpr(ctx, init->getLBraceLoc(), Inits,
1610 init->getRBraceLoc());
Sebastian Redl4a7eab22012-02-25 20:51:20 +00001611 arrayInit->setType(arrayType);
1612
1613 if (!cleanups.empty())
1614 arrayInit = ExprWithCleanups::Create(ctx, arrayInit, cleanups);
1615
1616 backingArray->setInit(arrayInit);
1617
1618 // Emit the definition of the array.
1619 EmitGlobalVarDefinition(backingArray);
1620
1621 // Inspect the initializer list to validate it and determine its type.
1622 // FIXME: doing this every time is probably inefficient; caching would be nice
1623 RecordDecl *record = init->getType()->castAs<RecordType>()->getDecl();
1624 RecordDecl::field_iterator field = record->field_begin();
1625 if (field == record->field_end()) {
1626 ErrorUnsupported(D, "weird std::initializer_list");
1627 return 0;
1628 }
1629 QualType elementPtr = ctx.getPointerType(elementType.withConst());
1630 // Start pointer.
1631 if (!ctx.hasSameType(field->getType(), elementPtr)) {
1632 ErrorUnsupported(D, "weird std::initializer_list");
1633 return 0;
1634 }
1635 ++field;
1636 if (field == record->field_end()) {
1637 ErrorUnsupported(D, "weird std::initializer_list");
1638 return 0;
1639 }
1640 bool isStartEnd = false;
1641 if (ctx.hasSameType(field->getType(), elementPtr)) {
1642 // End pointer.
1643 isStartEnd = true;
1644 } else if(!ctx.hasSameType(field->getType(), ctx.getSizeType())) {
1645 ErrorUnsupported(D, "weird std::initializer_list");
1646 return 0;
1647 }
1648
1649 // Now build an APValue representing the std::initializer_list.
1650 APValue initListValue(APValue::UninitStruct(), 0, 2);
1651 APValue &startField = initListValue.getStructField(0);
1652 APValue::LValuePathEntry startOffsetPathEntry;
1653 startOffsetPathEntry.ArrayIndex = 0;
1654 startField = APValue(APValue::LValueBase(backingArray),
1655 CharUnits::fromQuantity(0),
1656 llvm::makeArrayRef(startOffsetPathEntry),
1657 /*IsOnePastTheEnd=*/false, 0);
1658
1659 if (isStartEnd) {
1660 APValue &endField = initListValue.getStructField(1);
1661 APValue::LValuePathEntry endOffsetPathEntry;
1662 endOffsetPathEntry.ArrayIndex = numInits;
1663 endField = APValue(APValue::LValueBase(backingArray),
1664 ctx.getTypeSizeInChars(elementType) * numInits,
1665 llvm::makeArrayRef(endOffsetPathEntry),
1666 /*IsOnePastTheEnd=*/true, 0);
1667 } else {
1668 APValue &sizeField = initListValue.getStructField(1);
1669 sizeField = APValue(llvm::APSInt(numElements));
1670 }
1671
1672 // Emit the constant for the initializer_list.
Richard Smithbc6387672012-03-02 23:27:11 +00001673 llvm::Constant *llvmInit =
1674 EmitConstantValueForMemory(initListValue, D->getType());
Sebastian Redl4a7eab22012-02-25 20:51:20 +00001675 assert(llvmInit && "failed to initialize as constant");
1676 return llvmInit;
1677}
1678
Peter Collingbournef44bdf92012-05-20 21:08:35 +00001679unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D,
1680 unsigned AddrSpace) {
1681 if (LangOpts.CUDA && CodeGenOpts.CUDAIsDevice) {
1682 if (D->hasAttr<CUDAConstantAttr>())
1683 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant);
1684 else if (D->hasAttr<CUDASharedAttr>())
1685 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared);
1686 else
1687 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device);
1688 }
1689
1690 return AddrSpace;
1691}
1692
Daniel Dunbar9c426522008-07-29 23:18:29 +00001693void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
Chris Lattner9d3b0e02007-07-14 00:23:28 +00001694 llvm::Constant *Init = 0;
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001695 QualType ASTTy = D->getType();
Richard Smith6331c402012-02-13 22:16:19 +00001696 CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1697 bool NeedsGlobalCtor = false;
1698 bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
Mike Stump11289f42009-09-09 15:08:12 +00001699
Richard Smithdafff942012-01-14 04:30:29 +00001700 const VarDecl *InitDecl;
1701 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
Sebastian Redl4a7eab22012-02-25 20:51:20 +00001702
Anders Carlssonca4a5452010-01-26 17:43:42 +00001703 if (!InitExpr) {
Eli Friedman6859a1b2008-05-30 20:39:54 +00001704 // This is a tentative definition; tentative definitions are
Daniel Dunbar7dd749e2009-04-15 22:08:45 +00001705 // implicitly initialized with { 0 }.
1706 //
1707 // Note that tentative definitions are only emitted at the end of
1708 // a translation unit, so they should never have incomplete
1709 // type. In addition, EmitTentativeDefinition makes sure that we
1710 // never attempt to emit a tentative definition if a real one
1711 // exists. A use may still exists, however, so we still may need
1712 // to do a RAUW.
1713 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
Anders Carlssonf18318c2009-08-02 21:18:22 +00001714 Init = EmitNullConstant(D->getType());
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001715 } else {
Sebastian Redl4a7eab22012-02-25 20:51:20 +00001716 // If this is a std::initializer_list, emit the special initializer.
1717 Init = MaybeEmitGlobalStdInitializerListInitializer(D, InitExpr);
1718 // An empty init list will perform zero-initialization, which happens
1719 // to be exactly what we want.
1720 // FIXME: It does so in a global constructor, which is *not* what we
1721 // want.
1722
Fariborz Jahanian63628032012-06-26 16:06:38 +00001723 if (!Init) {
1724 initializedGlobalDecl = GlobalDecl(D);
Sebastian Redl4a7eab22012-02-25 20:51:20 +00001725 Init = EmitConstantInit(*InitDecl);
Fariborz Jahanian63628032012-06-26 16:06:38 +00001726 }
Eli Friedman719ed1a2009-02-20 01:18:21 +00001727 if (!Init) {
Anders Carlssonca4a5452010-01-26 17:43:42 +00001728 QualType T = InitExpr->getType();
Douglas Gregord450f062010-05-05 20:15:55 +00001729 if (D->getType()->isReferenceType())
1730 T = D->getType();
Richard Smithdafff942012-01-14 04:30:29 +00001731
David Blaikiebbafb8a2012-03-11 07:00:24 +00001732 if (getLangOpts().CPlusPlus) {
Anders Carlssonb8be93f2009-08-08 23:24:23 +00001733 Init = EmitNullConstant(T);
Richard Smith6331c402012-02-13 22:16:19 +00001734 NeedsGlobalCtor = true;
Anders Carlssonb8be93f2009-08-08 23:24:23 +00001735 } else {
1736 ErrorUnsupported(D, "static initializer");
1737 Init = llvm::UndefValue::get(getTypes().ConvertType(T));
1738 }
John McCall70013b62010-07-15 23:40:35 +00001739 } else {
1740 // We don't need an initializer, so remove the entry for the delayed
Richard Smith6331c402012-02-13 22:16:19 +00001741 // initializer position (just in case this entry was delayed) if we
1742 // also don't need to register a destructor.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001743 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
John McCall70013b62010-07-15 23:40:35 +00001744 DelayedCXXInitPosition.erase(D);
Eli Friedman719ed1a2009-02-20 01:18:21 +00001745 }
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001746 }
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001747
Chris Lattner2192fe52011-07-18 04:24:23 +00001748 llvm::Type* InitType = Init->getType();
Chris Lattner149927c2009-03-21 09:16:30 +00001749 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
Mike Stump11289f42009-09-09 15:08:12 +00001750
Chris Lattner149927c2009-03-21 09:16:30 +00001751 // Strip off a bitcast if we got one back.
1752 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
Chris Lattneraa64ca22009-07-16 16:48:25 +00001753 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
1754 // all zero index gep.
1755 CE->getOpcode() == llvm::Instruction::GetElementPtr);
Chris Lattner149927c2009-03-21 09:16:30 +00001756 Entry = CE->getOperand(0);
1757 }
Mike Stump11289f42009-09-09 15:08:12 +00001758
Chris Lattner149927c2009-03-21 09:16:30 +00001759 // Entry is now either a Function or GlobalVariable.
1760 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
Mike Stump11289f42009-09-09 15:08:12 +00001761
Chris Lattner149927c2009-03-21 09:16:30 +00001762 // We have a definition after a declaration with the wrong type.
1763 // We must make a new GlobalVariable* and update everything that used OldGV
1764 // (a declaration or tentative definition) with the new GlobalVariable*
1765 // (which will be a definition).
1766 //
1767 // This happens if there is a prototype for a global (e.g.
1768 // "extern int x[];") and then a definition of a different type (e.g.
1769 // "int x[10];"). This also happens when an initializer has a different type
1770 // from the type of the global (this happens with unions).
Chris Lattner149927c2009-03-21 09:16:30 +00001771 if (GV == 0 ||
1772 GV->getType()->getElementType() != InitType ||
Peter Collingbourne599cb8e2011-03-18 22:38:29 +00001773 GV->getType()->getAddressSpace() !=
Peter Collingbournef44bdf92012-05-20 21:08:35 +00001774 GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) {
Mike Stump11289f42009-09-09 15:08:12 +00001775
John McCall7ec50432010-03-19 23:29:14 +00001776 // Move the old entry aside so that we'll create a new one.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001777 Entry->setName(StringRef());
Daniel Dunbarb2f4cdb2009-02-19 05:36:41 +00001778
Chris Lattner149927c2009-03-21 09:16:30 +00001779 // Make a new global with the correct type, this is now guaranteed to work.
1780 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
Chris Lattnera85d68e2009-03-21 09:25:43 +00001781
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001782 // Replace all uses of the old global with the new global
Mike Stump11289f42009-09-09 15:08:12 +00001783 llvm::Constant *NewPtrForOldDecl =
Owen Andersonade90fd2009-07-29 18:54:39 +00001784 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
Chris Lattner149927c2009-03-21 09:16:30 +00001785 Entry->replaceAllUsesWith(NewPtrForOldDecl);
Eli Friedmanc18d9d52008-05-30 19:50:47 +00001786
1787 // Erase the old global, since it is no longer used.
Chris Lattner149927c2009-03-21 09:16:30 +00001788 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
Chris Lattner9d3b0e02007-07-14 00:23:28 +00001789 }
Devang Patel19c2b9a2007-10-26 16:31:40 +00001790
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001791 if (D->hasAttr<AnnotateAttr>())
1792 AddGlobalAnnotations(D, GV);
Nate Begemanfaae0812008-04-19 04:17:09 +00001793
Chris Lattnerd14bfa92007-07-13 05:13:43 +00001794 GV->setInitializer(Init);
Chris Lattnerf49573d2009-08-05 05:20:29 +00001795
1796 // If it is safe to mark the global 'constant', do so now.
Richard Smithe070fd22012-02-17 06:48:11 +00001797 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
1798 isTypeConstant(D->getType(), true));
Mike Stump11289f42009-09-09 15:08:12 +00001799
Ken Dyck160146e2010-01-27 17:10:57 +00001800 GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
Richard Smithe070fd22012-02-17 06:48:11 +00001801
Chris Lattnerd14bfa92007-07-13 05:13:43 +00001802 // Set the llvm linkage type as appropriate.
Fariborz Jahanian1518a5ec2010-10-27 16:21:54 +00001803 llvm::GlobalValue::LinkageTypes Linkage =
1804 GetLLVMLinkageVarDefinition(D, GV);
1805 GV->setLinkage(Linkage);
1806 if (Linkage == llvm::GlobalVariable::CommonLinkage)
Chris Lattnerf49573d2009-08-05 05:20:29 +00001807 // common vars aren't constant even if declared const.
1808 GV->setConstant(false);
Daniel Dunbard272cca2009-04-10 20:26:50 +00001809
Daniel Dunbar38932572009-04-14 08:05:55 +00001810 SetCommonAttributes(D, GV);
Daniel Dunbarf5f359f2009-04-14 06:00:08 +00001811
John McCallcdf7ef52010-11-06 09:44:32 +00001812 // Emit the initializer function if necessary.
Richard Smith6331c402012-02-13 22:16:19 +00001813 if (NeedsGlobalCtor || NeedsGlobalDtor)
1814 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
John McCallcdf7ef52010-11-06 09:44:32 +00001815
Kostya Serebryany28a26c82012-08-21 06:53:28 +00001816 // If we are compiling with ASan, add metadata indicating dynamically
1817 // initialized globals.
Will Dietzf54319c2013-01-18 11:30:38 +00001818 if (SanOpts.Address && NeedsGlobalCtor) {
Kostya Serebryany28a26c82012-08-21 06:53:28 +00001819 llvm::Module &M = getModule();
1820
1821 llvm::NamedMDNode *DynamicInitializers =
1822 M.getOrInsertNamedMetadata("llvm.asan.dynamically_initialized_globals");
1823 llvm::Value *GlobalToAdd[] = { GV };
1824 llvm::MDNode *ThisGlobal = llvm::MDNode::get(VMContext, GlobalToAdd);
1825 DynamicInitializers->addOperand(ThisGlobal);
1826 }
1827
Sanjiv Gupta158143a2008-06-05 08:59:10 +00001828 // Emit global variable debug information.
Eric Christopher7cdf9482011-10-13 21:45:18 +00001829 if (CGDebugInfo *DI = getModuleDebugInfo())
Douglas Gregorb0eea8b2012-10-23 20:05:01 +00001830 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
Alexey Samsonov74a38682012-05-04 07:39:27 +00001831 DI->EmitGlobalVariable(GV, D);
Chris Lattnerd14bfa92007-07-13 05:13:43 +00001832}
Chris Lattner09153c02007-06-22 18:48:09 +00001833
Fariborz Jahanian1518a5ec2010-10-27 16:21:54 +00001834llvm::GlobalValue::LinkageTypes
1835CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D,
1836 llvm::GlobalVariable *GV) {
1837 GVALinkage Linkage = getContext().GetGVALinkageForVariable(D);
1838 if (Linkage == GVA_Internal)
1839 return llvm::Function::InternalLinkage;
1840 else if (D->hasAttr<DLLImportAttr>())
1841 return llvm::Function::DLLImportLinkage;
1842 else if (D->hasAttr<DLLExportAttr>())
1843 return llvm::Function::DLLExportLinkage;
1844 else if (D->hasAttr<WeakAttr>()) {
1845 if (GV->isConstant())
1846 return llvm::GlobalVariable::WeakODRLinkage;
1847 else
1848 return llvm::GlobalVariable::WeakAnyLinkage;
1849 } else if (Linkage == GVA_TemplateInstantiation ||
1850 Linkage == GVA_ExplicitTemplateInstantiation)
John McCalla97f3292011-04-12 01:46:54 +00001851 return llvm::GlobalVariable::WeakODRLinkage;
David Blaikiebbafb8a2012-03-11 07:00:24 +00001852 else if (!getLangOpts().CPlusPlus &&
Eric Christopher8a2ee392010-12-02 02:45:55 +00001853 ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) ||
1854 D->getAttr<CommonAttr>()) &&
Fariborz Jahanian1518a5ec2010-10-27 16:21:54 +00001855 !D->hasExternalStorage() && !D->getInit() &&
Fariborz Jahanianab578bf2011-06-20 17:50:03 +00001856 !D->getAttr<SectionAttr>() && !D->isThreadSpecified() &&
1857 !D->getAttr<WeakImportAttr>()) {
Fariborz Jahanian1518a5ec2010-10-27 16:21:54 +00001858 // Thread local vars aren't considered common linkage.
1859 return llvm::GlobalVariable::CommonLinkage;
1860 }
1861 return llvm::GlobalVariable::ExternalLinkage;
1862}
1863
John McCall49954ca2012-12-12 22:21:47 +00001864/// Replace the uses of a function that was declared with a non-proto type.
1865/// We want to silently drop extra arguments from call sites
1866static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
1867 llvm::Function *newFn) {
1868 // Fast path.
1869 if (old->use_empty()) return;
1870
1871 llvm::Type *newRetTy = newFn->getReturnType();
1872 SmallVector<llvm::Value*, 4> newArgs;
1873
1874 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
1875 ui != ue; ) {
1876 llvm::Value::use_iterator use = ui++; // Increment before the use is erased.
1877 llvm::User *user = *use;
1878
1879 // Recognize and replace uses of bitcasts. Most calls to
1880 // unprototyped functions will use bitcasts.
1881 if (llvm::ConstantExpr *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
1882 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
1883 replaceUsesOfNonProtoConstant(bitcast, newFn);
1884 continue;
1885 }
1886
1887 // Recognize calls to the function.
1888 llvm::CallSite callSite(user);
1889 if (!callSite) continue;
1890 if (!callSite.isCallee(use)) continue;
1891
1892 // If the return types don't match exactly, then we can't
1893 // transform this call unless it's dead.
1894 if (callSite->getType() != newRetTy && !callSite->use_empty())
1895 continue;
1896
1897 // Get the call site's attribute list.
Bill Wendling290d9522013-01-27 02:46:53 +00001898 SmallVector<llvm::AttributeSet, 8> newAttrs;
John McCall49954ca2012-12-12 22:21:47 +00001899 llvm::AttributeSet oldAttrs = callSite.getAttributes();
1900
1901 // Collect any return attributes from the call.
Bill Wendling304f6f02013-01-21 21:57:40 +00001902 if (oldAttrs.hasAttributes(llvm::AttributeSet::ReturnIndex))
Bill Wendlingb7abb302013-01-21 22:45:00 +00001903 newAttrs.push_back(
Bill Wendling290d9522013-01-27 02:46:53 +00001904 llvm::AttributeSet::get(newFn->getContext(),
1905 oldAttrs.getRetAttributes()));
John McCall49954ca2012-12-12 22:21:47 +00001906
1907 // If the function was passed too few arguments, don't transform.
1908 unsigned newNumArgs = newFn->arg_size();
1909 if (callSite.arg_size() < newNumArgs) continue;
1910
1911 // If extra arguments were passed, we silently drop them.
1912 // If any of the types mismatch, we don't transform.
1913 unsigned argNo = 0;
1914 bool dontTransform = false;
1915 for (llvm::Function::arg_iterator ai = newFn->arg_begin(),
1916 ae = newFn->arg_end(); ai != ae; ++ai, ++argNo) {
1917 if (callSite.getArgument(argNo)->getType() != ai->getType()) {
1918 dontTransform = true;
1919 break;
1920 }
1921
1922 // Add any parameter attributes.
Bill Wendlingce2f9c52013-01-23 06:15:10 +00001923 if (oldAttrs.hasAttributes(argNo + 1))
1924 newAttrs.
Bill Wendling290d9522013-01-27 02:46:53 +00001925 push_back(llvm::
1926 AttributeSet::get(newFn->getContext(),
1927 oldAttrs.getParamAttributes(argNo + 1)));
John McCall49954ca2012-12-12 22:21:47 +00001928 }
1929 if (dontTransform)
1930 continue;
1931
Bill Wendling63ffde52013-01-18 21:26:07 +00001932 if (oldAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex))
Bill Wendling290d9522013-01-27 02:46:53 +00001933 newAttrs.push_back(llvm::AttributeSet::get(newFn->getContext(),
1934 oldAttrs.getFnAttributes()));
John McCall49954ca2012-12-12 22:21:47 +00001935
1936 // Okay, we can transform this. Create the new call instruction and copy
1937 // over the required information.
1938 newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo);
1939
1940 llvm::CallSite newCall;
1941 if (callSite.isCall()) {
1942 newCall = llvm::CallInst::Create(newFn, newArgs, "",
1943 callSite.getInstruction());
1944 } else {
1945 llvm::InvokeInst *oldInvoke =
1946 cast<llvm::InvokeInst>(callSite.getInstruction());
1947 newCall = llvm::InvokeInst::Create(newFn,
1948 oldInvoke->getNormalDest(),
1949 oldInvoke->getUnwindDest(),
1950 newArgs, "",
1951 callSite.getInstruction());
1952 }
1953 newArgs.clear(); // for the next iteration
1954
1955 if (!newCall->getType()->isVoidTy())
1956 newCall->takeName(callSite.getInstruction());
1957 newCall.setAttributes(
1958 llvm::AttributeSet::get(newFn->getContext(), newAttrs));
1959 newCall.setCallingConv(callSite.getCallingConv());
1960
1961 // Finally, remove the old call, replacing any uses with the new one.
1962 if (!callSite->use_empty())
1963 callSite->replaceAllUsesWith(newCall.getInstruction());
1964
1965 // Copy debug location attached to CI.
1966 if (!callSite->getDebugLoc().isUnknown())
1967 newCall->setDebugLoc(callSite->getDebugLoc());
1968 callSite->eraseFromParent();
1969 }
1970}
1971
Chris Lattner36797ab2009-05-05 06:16:31 +00001972/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
1973/// implement a function with no prototype, e.g. "int foo() {}". If there are
1974/// existing call uses of the old function in the module, this adjusts them to
1975/// call the new function directly.
1976///
1977/// This is not just a cleanup: the always_inline pass requires direct calls to
1978/// functions to be able to inline them. If there is a bitcast in the way, it
1979/// won't inline them. Instcombine normally deletes these calls, but it isn't
1980/// run at -O0.
1981static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
1982 llvm::Function *NewFn) {
1983 // If we're redefining a global as a function, don't transform it.
John McCall49954ca2012-12-12 22:21:47 +00001984 if (!isa<llvm::Function>(Old)) return;
Mike Stump11289f42009-09-09 15:08:12 +00001985
John McCall49954ca2012-12-12 22:21:47 +00001986 replaceUsesOfNonProtoConstant(Old, NewFn);
Chris Lattner36797ab2009-05-05 06:16:31 +00001987}
1988
Rafael Espindoladf88f6f2012-03-08 15:51:03 +00001989void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
1990 TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind();
1991 // If we have a definition, this might be a deferred decl. If the
1992 // instantiation is explicit, make sure we emit it at the end.
1993 if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
1994 GetAddrOfGlobalVar(VD);
Argyrios Kyrtzidis8a27b2b2013-02-24 00:05:01 +00001995
1996 EmitTopLevelDecl(VD);
Rafael Espindola189fa742012-03-05 10:54:55 +00001997}
Daniel Dunbar9c426522008-07-29 23:18:29 +00001998
Chris Lattnere0be0df2009-05-12 21:21:08 +00001999void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
Chris Lattnere0be0df2009-05-12 21:21:08 +00002000 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
John McCalla738c252011-03-09 04:27:21 +00002001
John McCall46288ef2011-03-09 08:12:35 +00002002 // Compute the function info and LLVM type.
John McCalla729c622012-02-17 03:33:10 +00002003 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
2004 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
John McCalla738c252011-03-09 04:27:21 +00002005
Chris Lattnereb7466d2009-05-12 20:58:15 +00002006 // Get or create the prototype for the function.
Chris Lattnere0be0df2009-05-12 21:21:08 +00002007 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
Mike Stump11289f42009-09-09 15:08:12 +00002008
Chris Lattnera85d68e2009-03-21 09:25:43 +00002009 // Strip off a bitcast if we got one back.
2010 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
2011 assert(CE->getOpcode() == llvm::Instruction::BitCast);
2012 Entry = CE->getOperand(0);
2013 }
Mike Stump11289f42009-09-09 15:08:12 +00002014
2015
Chris Lattnera85d68e2009-03-21 09:25:43 +00002016 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
Chris Lattner36797ab2009-05-05 06:16:31 +00002017 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
Mike Stump11289f42009-09-09 15:08:12 +00002018
Daniel Dunbar99d28352009-03-09 23:53:08 +00002019 // If the types mismatch then we have to rewrite the definition.
Chris Lattner36797ab2009-05-05 06:16:31 +00002020 assert(OldFn->isDeclaration() &&
Chris Lattnera85d68e2009-03-21 09:25:43 +00002021 "Shouldn't replace non-declaration");
Chris Lattner832323e2009-03-21 08:53:37 +00002022
Chris Lattner5eaee562009-03-21 08:38:50 +00002023 // F is the Function* for the one with the wrong type, we must make a new
2024 // Function* and update everything that used F (a declaration) with the new
2025 // Function* (which will be a definition).
2026 //
2027 // This happens if there is a prototype for a function
2028 // (e.g. "int f()") and then a definition of a different type
John McCall7ec50432010-03-19 23:29:14 +00002029 // (e.g. "int f(int x)"). Move the old function aside so that it
2030 // doesn't interfere with GetAddrOfFunction.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002031 OldFn->setName(StringRef());
Chris Lattnere0be0df2009-05-12 21:21:08 +00002032 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
Mike Stump11289f42009-09-09 15:08:12 +00002033
John McCall49954ca2012-12-12 22:21:47 +00002034 // This might be an implementation of a function without a
2035 // prototype, in which case, try to do special replacement of
2036 // calls which match the new prototype. The really key thing here
2037 // is that we also potentially drop arguments from the call site
2038 // so as to make a direct call, which makes the inliner happier
2039 // and suppresses a number of optimizer warnings (!) about
2040 // dropping arguments.
2041 if (!OldFn->use_empty()) {
Chris Lattner36797ab2009-05-05 06:16:31 +00002042 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
Chris Lattnereb7466d2009-05-12 20:58:15 +00002043 OldFn->removeDeadConstantUsers();
2044 }
Mike Stump11289f42009-09-09 15:08:12 +00002045
Chris Lattner5eaee562009-03-21 08:38:50 +00002046 // Replace uses of F with the Function we will endow with a body.
Chris Lattner36797ab2009-05-05 06:16:31 +00002047 if (!Entry->use_empty()) {
Mike Stump11289f42009-09-09 15:08:12 +00002048 llvm::Constant *NewPtrForOldDecl =
Owen Andersonade90fd2009-07-29 18:54:39 +00002049 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
Chris Lattner36797ab2009-05-05 06:16:31 +00002050 Entry->replaceAllUsesWith(NewPtrForOldDecl);
2051 }
Mike Stump11289f42009-09-09 15:08:12 +00002052
Chris Lattner5eaee562009-03-21 08:38:50 +00002053 // Ok, delete the old function now, which is dead.
Chris Lattner36797ab2009-05-05 06:16:31 +00002054 OldFn->eraseFromParent();
Mike Stump11289f42009-09-09 15:08:12 +00002055
Chris Lattnera85d68e2009-03-21 09:25:43 +00002056 Entry = NewFn;
Daniel Dunbar9c426522008-07-29 23:18:29 +00002057 }
Mike Stump11289f42009-09-09 15:08:12 +00002058
John McCall8e7cb6d2010-11-02 21:04:24 +00002059 // We need to set linkage and visibility on the function before
2060 // generating code for it because various parts of IR generation
2061 // want to propagate this information down (e.g. to local static
2062 // declarations).
Chris Lattnera85d68e2009-03-21 09:25:43 +00002063 llvm::Function *Fn = cast<llvm::Function>(Entry);
John McCall7cb02202010-05-25 04:30:21 +00002064 setFunctionLinkage(D, Fn);
Daniel Dunbar9c426522008-07-29 23:18:29 +00002065
John McCall8e7cb6d2010-11-02 21:04:24 +00002066 // FIXME: this is redundant with part of SetFunctionDefinitionAttributes
Anders Carlssonc6a47892011-01-29 19:39:23 +00002067 setGlobalVisibility(Fn, D);
John McCall8e7cb6d2010-11-02 21:04:24 +00002068
John McCalla738c252011-03-09 04:27:21 +00002069 CodeGenFunction(*this).GenerateCode(D, Fn, FI);
Daniel Dunbar74aa7e12008-08-01 00:01:51 +00002070
Daniel Dunbar38932572009-04-14 08:05:55 +00002071 SetFunctionDefinitionAttributes(D, Fn);
2072 SetLLVMFunctionAttributesForDefinition(D, Fn);
Mike Stump11289f42009-09-09 15:08:12 +00002073
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00002074 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
Daniel Dunbar0beedc12008-09-08 23:44:31 +00002075 AddGlobalCtor(Fn, CA->getPriority());
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00002076 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
Daniel Dunbar0beedc12008-09-08 23:44:31 +00002077 AddGlobalDtor(Fn, DA->getPriority());
Julien Lerouge5a6b6982011-09-09 22:41:49 +00002078 if (D->hasAttr<AnnotateAttr>())
2079 AddGlobalAnnotations(D, Fn);
Daniel Dunbar9c426522008-07-29 23:18:29 +00002080}
2081
John McCall7ec50432010-03-19 23:29:14 +00002082void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
2083 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00002084 const AliasAttr *AA = D->getAttr<AliasAttr>();
Chris Lattner54041692009-03-22 21:47:11 +00002085 assert(AA && "Not an alias?");
2086
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002087 StringRef MangledName = getMangledName(GD);
Mike Stump11289f42009-09-09 15:08:12 +00002088
John McCall7ec50432010-03-19 23:29:14 +00002089 // If there is a definition in the module, then it wins over the alias.
2090 // This is dubious, but allow it to be safe. Just ignore the alias.
2091 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
2092 if (Entry && !Entry->isDeclaration())
2093 return;
2094
Chris Lattner2192fe52011-07-18 04:24:23 +00002095 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
Chris Lattner54041692009-03-22 21:47:11 +00002096
2097 // Create a reference to the named value. This ensures that it is emitted
2098 // if a deferred decl.
2099 llvm::Constant *Aliasee;
2100 if (isa<llvm::FunctionType>(DeclTy))
Alex Rosenbergba036122012-10-05 23:12:53 +00002101 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
Anders Carlsson3c239482011-02-05 04:35:53 +00002102 /*ForVTable=*/false);
Chris Lattner54041692009-03-22 21:47:11 +00002103 else
John McCall7ec50432010-03-19 23:29:14 +00002104 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Owen Anderson9793f0e2009-07-29 22:16:19 +00002105 llvm::PointerType::getUnqual(DeclTy), 0);
Chris Lattner54041692009-03-22 21:47:11 +00002106
2107 // Create the new alias itself, but don't set a name yet.
Mike Stump11289f42009-09-09 15:08:12 +00002108 llvm::GlobalValue *GA =
Chris Lattner54041692009-03-22 21:47:11 +00002109 new llvm::GlobalAlias(Aliasee->getType(),
2110 llvm::Function::ExternalLinkage,
2111 "", Aliasee, &getModule());
Mike Stump11289f42009-09-09 15:08:12 +00002112
Chris Lattner54041692009-03-22 21:47:11 +00002113 if (Entry) {
John McCall7ec50432010-03-19 23:29:14 +00002114 assert(Entry->isDeclaration());
2115
Chris Lattner54041692009-03-22 21:47:11 +00002116 // If there is a declaration in the module, then we had an extern followed
2117 // by the alias, as in:
2118 // extern int test6();
2119 // ...
2120 // int test6() __attribute__((alias("test7")));
2121 //
2122 // Remove it and replace uses of it with the alias.
John McCall7ec50432010-03-19 23:29:14 +00002123 GA->takeName(Entry);
Mike Stump11289f42009-09-09 15:08:12 +00002124
Owen Andersonade90fd2009-07-29 18:54:39 +00002125 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
Chris Lattner54041692009-03-22 21:47:11 +00002126 Entry->getType()));
Chris Lattner54041692009-03-22 21:47:11 +00002127 Entry->eraseFromParent();
John McCall7ec50432010-03-19 23:29:14 +00002128 } else {
Anders Carlssonea836bc2010-06-22 16:16:50 +00002129 GA->setName(MangledName);
Chris Lattner54041692009-03-22 21:47:11 +00002130 }
Mike Stump11289f42009-09-09 15:08:12 +00002131
Daniel Dunbar38932572009-04-14 08:05:55 +00002132 // Set attributes which are particular to an alias; this is a
2133 // specialization of the attributes which may be set on a global
2134 // variable/function.
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00002135 if (D->hasAttr<DLLExportAttr>()) {
Daniel Dunbar38932572009-04-14 08:05:55 +00002136 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2137 // The dllexport attribute is ignored for undefined symbols.
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00002138 if (FD->hasBody())
Daniel Dunbar38932572009-04-14 08:05:55 +00002139 GA->setLinkage(llvm::Function::DLLExportLinkage);
2140 } else {
2141 GA->setLinkage(llvm::Function::DLLExportLinkage);
2142 }
Mike Stump11289f42009-09-09 15:08:12 +00002143 } else if (D->hasAttr<WeakAttr>() ||
Rafael Espindolac18086a2010-02-23 22:00:30 +00002144 D->hasAttr<WeakRefAttr>() ||
Douglas Gregor20b2ebd2011-03-23 00:50:03 +00002145 D->isWeakImported()) {
Daniel Dunbar38932572009-04-14 08:05:55 +00002146 GA->setLinkage(llvm::Function::WeakAnyLinkage);
2147 }
2148
2149 SetCommonAttributes(D, GA);
Chris Lattner54041692009-03-22 21:47:11 +00002150}
2151
Benjamin Kramer8d375ce2011-07-14 17:45:50 +00002152llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
Chris Lattner54b16772011-07-23 17:14:25 +00002153 ArrayRef<llvm::Type*> Tys) {
Jay Foadb804a2b2011-07-12 14:06:48 +00002154 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
Benjamin Kramer8d375ce2011-07-14 17:45:50 +00002155 Tys);
Chris Lattnerb8be97e2007-12-18 00:25:38 +00002156}
Chris Lattner1eec6602007-08-31 04:31:45 +00002157
Daniel Dunbar64509b22009-07-23 22:52:48 +00002158static llvm::StringMapEntry<llvm::Constant*> &
2159GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
2160 const StringLiteral *Literal,
Daniel Dunbar91ade142009-07-23 23:41:22 +00002161 bool TargetIsLSB,
Daniel Dunbar64509b22009-07-23 22:52:48 +00002162 bool &IsUTF16,
2163 unsigned &StringLength) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002164 StringRef String = Literal->getString();
Benjamin Kramer35b077e2010-08-17 12:54:38 +00002165 unsigned NumBytes = String.size();
Daniel Dunbar64509b22009-07-23 22:52:48 +00002166
Daniel Dunbarb879c3c2009-09-22 10:03:52 +00002167 // Check for simple case.
2168 if (!Literal->containsNonAsciiOrNull()) {
2169 StringLength = NumBytes;
Benjamin Kramer35b077e2010-08-17 12:54:38 +00002170 return Map.GetOrCreateValue(String);
Daniel Dunbarb879c3c2009-09-22 10:03:52 +00002171 }
2172
Bill Wendling82b87f12012-03-30 00:26:17 +00002173 // Otherwise, convert the UTF8 literals into a string of shorts.
2174 IsUTF16 = true;
2175
2176 SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
Roman Divackye6377112012-09-06 15:59:27 +00002177 const UTF8 *FromPtr = (const UTF8 *)String.data();
Daniel Dunbar64509b22009-07-23 22:52:48 +00002178 UTF16 *ToPtr = &ToBuf[0];
Mike Stump11289f42009-09-09 15:08:12 +00002179
Fariborz Jahanian535618b2010-09-07 19:57:04 +00002180 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
2181 &ToPtr, ToPtr + NumBytes,
2182 strictConversion);
Mike Stump11289f42009-09-09 15:08:12 +00002183
Daniel Dunbar91ade142009-07-23 23:41:22 +00002184 // ConvertUTF8toUTF16 returns the length in ToPtr.
Daniel Dunbar64509b22009-07-23 22:52:48 +00002185 StringLength = ToPtr - &ToBuf[0];
Daniel Dunbar91ade142009-07-23 23:41:22 +00002186
Bill Wendling82b87f12012-03-30 00:26:17 +00002187 // Add an explicit null.
2188 *ToPtr = 0;
2189 return Map.
2190 GetOrCreateValue(StringRef(reinterpret_cast<const char *>(ToBuf.data()),
2191 (StringLength + 1) * 2));
Daniel Dunbar64509b22009-07-23 22:52:48 +00002192}
2193
Fariborz Jahaniana52b1f72011-05-13 18:13:10 +00002194static llvm::StringMapEntry<llvm::Constant*> &
2195GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map,
Bill Wendling07635cc2012-03-29 22:12:09 +00002196 const StringLiteral *Literal,
2197 unsigned &StringLength) {
2198 StringRef String = Literal->getString();
2199 StringLength = String.size();
2200 return Map.GetOrCreateValue(String);
Fariborz Jahaniana52b1f72011-05-13 18:13:10 +00002201}
2202
Daniel Dunbar64509b22009-07-23 22:52:48 +00002203llvm::Constant *
2204CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
2205 unsigned StringLength = 0;
2206 bool isUTF16 = false;
2207 llvm::StringMapEntry<llvm::Constant*> &Entry =
Mike Stump11289f42009-09-09 15:08:12 +00002208 GetConstantCFStringEntry(CFConstantStringMap, Literal,
Micah Villmowdd31ca12012-10-08 16:25:52 +00002209 getDataLayout().isLittleEndian(),
Daniel Dunbar91ade142009-07-23 23:41:22 +00002210 isUTF16, StringLength);
Mike Stump11289f42009-09-09 15:08:12 +00002211
Daniel Dunbar64509b22009-07-23 22:52:48 +00002212 if (llvm::Constant *C = Entry.getValue())
2213 return C;
Mike Stump11289f42009-09-09 15:08:12 +00002214
Chris Lattnerece04092012-02-07 00:39:47 +00002215 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
Daniel Dunbard644ad62008-08-23 18:37:06 +00002216 llvm::Constant *Zeros[] = { Zero, Zero };
Mike Stump11289f42009-09-09 15:08:12 +00002217
Chris Lattneraa64ca22009-07-16 16:48:25 +00002218 // If we don't already have it, get __CFConstantStringClassReference.
Anders Carlssonb04ea612007-08-21 00:21:21 +00002219 if (!CFConstantStringClassRef) {
Chris Lattner2192fe52011-07-18 04:24:23 +00002220 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Owen Anderson9793f0e2009-07-29 22:16:19 +00002221 Ty = llvm::ArrayType::get(Ty, 0);
Mike Stump11289f42009-09-09 15:08:12 +00002222 llvm::Constant *GV = CreateRuntimeVariable(Ty,
Chris Lattneraa64ca22009-07-16 16:48:25 +00002223 "__CFConstantStringClassReference");
Daniel Dunbard644ad62008-08-23 18:37:06 +00002224 // Decay array -> ptr
2225 CFConstantStringClassRef =
Jay Foaded8db7d2011-07-21 14:31:17 +00002226 llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Anders Carlssonb04ea612007-08-21 00:21:21 +00002227 }
Mike Stump11289f42009-09-09 15:08:12 +00002228
Anders Carlssonc2480a52008-11-15 18:54:24 +00002229 QualType CFTy = getContext().getCFConstantStringType();
Daniel Dunbard644ad62008-08-23 18:37:06 +00002230
Chris Lattner2192fe52011-07-18 04:24:23 +00002231 llvm::StructType *STy =
Anders Carlssonc2480a52008-11-15 18:54:24 +00002232 cast<llvm::StructType>(getTypes().ConvertType(CFTy));
2233
Benjamin Kramer22d24c22011-10-15 12:20:02 +00002234 llvm::Constant *Fields[4];
Douglas Gregor91f84212008-12-11 16:49:14 +00002235
Anders Carlssonb04ea612007-08-21 00:21:21 +00002236 // Class pointer.
Anders Carlsson157c3212009-08-16 05:55:31 +00002237 Fields[0] = CFConstantStringClassRef;
Mike Stump11289f42009-09-09 15:08:12 +00002238
Anders Carlssonb04ea612007-08-21 00:21:21 +00002239 // Flags.
Chris Lattner2192fe52011-07-18 04:24:23 +00002240 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
Mike Stump11289f42009-09-09 15:08:12 +00002241 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
Anders Carlsson157c3212009-08-16 05:55:31 +00002242 llvm::ConstantInt::get(Ty, 0x07C8);
2243
Anders Carlssonb04ea612007-08-21 00:21:21 +00002244 // String pointer.
Bill Wendling82b87f12012-03-30 00:26:17 +00002245 llvm::Constant *C = 0;
2246 if (isUTF16) {
2247 ArrayRef<uint16_t> Arr =
David Greene0a528db2013-01-15 22:09:41 +00002248 llvm::makeArrayRef<uint16_t>(reinterpret_cast<uint16_t*>(
2249 const_cast<char *>(Entry.getKey().data())),
Bill Wendling82b87f12012-03-30 00:26:17 +00002250 Entry.getKey().size() / 2);
2251 C = llvm::ConstantDataArray::get(VMContext, Arr);
2252 } else {
2253 C = llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
2254 }
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +00002255
Chris Lattner3afa3e12009-07-16 05:03:48 +00002256 llvm::GlobalValue::LinkageTypes Linkage;
Bill Wendling86131f22012-01-10 08:46:39 +00002257 if (isUTF16)
Chris Lattner4f8a2e22009-10-14 05:55:45 +00002258 // FIXME: why do utf strings get "_" labels instead of "L" labels?
Chris Lattner3afa3e12009-07-16 05:03:48 +00002259 Linkage = llvm::GlobalValue::InternalLinkage;
Bill Wendling86131f22012-01-10 08:46:39 +00002260 else
Rafael Espindola7a6cf012011-03-14 17:55:00 +00002261 // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error
2262 // when using private linkage. It is not clear if this is a bug in ld
2263 // or a reasonable new restriction.
Rafael Espindola0c1f0982011-03-14 21:08:19 +00002264 Linkage = llvm::GlobalValue::LinkerPrivateLinkage;
Chris Lattner4f8a2e22009-10-14 05:55:45 +00002265
Bill Wendling86131f22012-01-10 08:46:39 +00002266 // Note: -fwritable-strings doesn't make the backing store strings of
2267 // CFStrings writable. (See <rdar://problem/10657500>)
Mike Stump11289f42009-09-09 15:08:12 +00002268 llvm::GlobalVariable *GV =
Bill Wendling86131f22012-01-10 08:46:39 +00002269 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
2270 Linkage, C, ".str");
Rafael Espindolae79d43da2011-01-17 16:31:00 +00002271 GV->setUnnamedAddr(true);
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +00002272 if (isUTF16) {
Ken Dycka0f99ff2010-01-26 18:46:23 +00002273 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
2274 GV->setAlignment(Align.getQuantity());
Daniel Dunbar9c8cd4c2011-04-12 23:30:52 +00002275 } else {
2276 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2277 GV->setAlignment(Align.getQuantity());
Daniel Dunbarfd6cfcf2009-04-03 00:57:44 +00002278 }
Bill Wendling82b87f12012-03-30 00:26:17 +00002279
2280 // String.
Jay Foaded8db7d2011-07-21 14:31:17 +00002281 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Anders Carlsson157c3212009-08-16 05:55:31 +00002282
Bill Wendling82b87f12012-03-30 00:26:17 +00002283 if (isUTF16)
2284 // Cast the UTF16 string to the correct type.
2285 Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy);
2286
Anders Carlssonb04ea612007-08-21 00:21:21 +00002287 // String length.
2288 Ty = getTypes().ConvertType(getContext().LongTy);
Anders Carlsson157c3212009-08-16 05:55:31 +00002289 Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
Mike Stump11289f42009-09-09 15:08:12 +00002290
Anders Carlssonb04ea612007-08-21 00:21:21 +00002291 // The struct.
Owen Anderson0e0189d2009-07-27 22:29:56 +00002292 C = llvm::ConstantStruct::get(STy, Fields);
Mike Stump11289f42009-09-09 15:08:12 +00002293 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2294 llvm::GlobalVariable::PrivateLinkage, C,
Chris Lattner3afa3e12009-07-16 05:03:48 +00002295 "_unnamed_cfstring_");
Douglas Gregore8bbc122011-09-02 00:18:52 +00002296 if (const char *Sect = getContext().getTargetInfo().getCFStringSection())
Daniel Dunbar08b216a2009-03-31 23:42:16 +00002297 GV->setSection(Sect);
Daniel Dunbar64509b22009-07-23 22:52:48 +00002298 Entry.setValue(GV);
Mike Stump11289f42009-09-09 15:08:12 +00002299
Anders Carlsson41b7c6b2007-11-01 00:41:52 +00002300 return GV;
Anders Carlssonb04ea612007-08-21 00:21:21 +00002301}
Chris Lattnerfb300092007-11-28 05:34:05 +00002302
Douglas Gregorabf4e0d2011-08-09 15:54:21 +00002303static RecordDecl *
2304CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK,
2305 DeclContext *DC, IdentifierInfo *Id) {
2306 SourceLocation Loc;
David Blaikiebbafb8a2012-03-11 07:00:24 +00002307 if (Ctx.getLangOpts().CPlusPlus)
Douglas Gregorabf4e0d2011-08-09 15:54:21 +00002308 return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2309 else
2310 return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2311}
2312
Fariborz Jahanian63408e82010-04-22 20:26:39 +00002313llvm::Constant *
Fariborz Jahanian50c925f2010-10-19 17:19:29 +00002314CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002315 unsigned StringLength = 0;
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002316 llvm::StringMapEntry<llvm::Constant*> &Entry =
Fariborz Jahaniana52b1f72011-05-13 18:13:10 +00002317 GetConstantStringEntry(CFConstantStringMap, Literal, StringLength);
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002318
2319 if (llvm::Constant *C = Entry.getValue())
2320 return C;
2321
Chris Lattner00a10ca2012-02-06 22:47:00 +00002322 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002323 llvm::Constant *Zeros[] = { Zero, Zero };
2324
Fariborz Jahaniand3fa7012010-04-23 22:33:39 +00002325 // If we don't already have it, get _NSConstantStringClassReference.
Fariborz Jahanian50c925f2010-10-19 17:19:29 +00002326 if (!ConstantStringClassRef) {
David Blaikiebbafb8a2012-03-11 07:00:24 +00002327 std::string StringClass(getLangOpts().ObjCConstantStringClass);
Chris Lattner2192fe52011-07-18 04:24:23 +00002328 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Fariborz Jahanian50c925f2010-10-19 17:19:29 +00002329 llvm::Constant *GV;
John McCall5fb5df92012-06-20 06:18:46 +00002330 if (LangOpts.ObjCRuntime.isNonFragile()) {
Fariborz Jahanianccdfa392011-05-17 22:46:11 +00002331 std::string str =
2332 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
2333 : "OBJC_CLASS_$_" + StringClass;
Fariborz Jahanian7bd3d1c2011-05-17 22:21:16 +00002334 GV = getObjCRuntime().GetClassGlobal(str);
2335 // Make sure the result is of the correct type.
Chris Lattner2192fe52011-07-18 04:24:23 +00002336 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
Fariborz Jahanian7bd3d1c2011-05-17 22:21:16 +00002337 ConstantStringClassRef =
2338 llvm::ConstantExpr::getBitCast(GV, PTy);
2339 } else {
Fariborz Jahanianccdfa392011-05-17 22:46:11 +00002340 std::string str =
2341 StringClass.empty() ? "_NSConstantStringClassReference"
2342 : "_" + StringClass + "ClassReference";
Chris Lattner2192fe52011-07-18 04:24:23 +00002343 llvm::Type *PTy = llvm::ArrayType::get(Ty, 0);
Fariborz Jahanianccdfa392011-05-17 22:46:11 +00002344 GV = CreateRuntimeVariable(PTy, str);
Fariborz Jahanian7bd3d1c2011-05-17 22:21:16 +00002345 // Decay array -> ptr
2346 ConstantStringClassRef =
Jay Foaded8db7d2011-07-21 14:31:17 +00002347 llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Fariborz Jahanian50c925f2010-10-19 17:19:29 +00002348 }
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002349 }
Douglas Gregorabf4e0d2011-08-09 15:54:21 +00002350
2351 if (!NSConstantStringType) {
2352 // Construct the type for a constant NSString.
2353 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2354 Context.getTranslationUnitDecl(),
2355 &Context.Idents.get("__builtin_NSString"));
2356 D->startDefinition();
2357
2358 QualType FieldTypes[3];
2359
2360 // const int *isa;
2361 FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst());
2362 // const char *str;
2363 FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst());
2364 // unsigned int length;
2365 FieldTypes[2] = Context.UnsignedIntTy;
2366
2367 // Create fields
2368 for (unsigned i = 0; i < 3; ++i) {
2369 FieldDecl *Field = FieldDecl::Create(Context, D,
2370 SourceLocation(),
2371 SourceLocation(), 0,
2372 FieldTypes[i], /*TInfo=*/0,
2373 /*BitWidth=*/0,
2374 /*Mutable=*/false,
Richard Smith2b013182012-06-10 03:12:00 +00002375 ICIS_NoInit);
Douglas Gregorabf4e0d2011-08-09 15:54:21 +00002376 Field->setAccess(AS_public);
2377 D->addDecl(Field);
2378 }
2379
2380 D->completeDefinition();
2381 QualType NSTy = Context.getTagDeclType(D);
2382 NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy));
2383 }
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002384
Benjamin Kramer22d24c22011-10-15 12:20:02 +00002385 llvm::Constant *Fields[3];
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002386
2387 // Class pointer.
Fariborz Jahanian50c925f2010-10-19 17:19:29 +00002388 Fields[0] = ConstantStringClassRef;
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002389
2390 // String pointer.
Chris Lattner9c818332012-02-05 02:30:40 +00002391 llvm::Constant *C =
2392 llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002393
2394 llvm::GlobalValue::LinkageTypes Linkage;
2395 bool isConstant;
Fariborz Jahaniana52b1f72011-05-13 18:13:10 +00002396 Linkage = llvm::GlobalValue::PrivateLinkage;
David Blaikiebbafb8a2012-03-11 07:00:24 +00002397 isConstant = !LangOpts.WritableStrings;
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002398
2399 llvm::GlobalVariable *GV =
2400 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
2401 ".str");
Rafael Espindolade089d42011-01-17 22:11:21 +00002402 GV->setUnnamedAddr(true);
Fariborz Jahaniana52b1f72011-05-13 18:13:10 +00002403 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2404 GV->setAlignment(Align.getQuantity());
Jay Foaded8db7d2011-07-21 14:31:17 +00002405 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002406
2407 // String length.
Chris Lattner2192fe52011-07-18 04:24:23 +00002408 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002409 Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
2410
2411 // The struct.
Douglas Gregorabf4e0d2011-08-09 15:54:21 +00002412 C = llvm::ConstantStruct::get(NSConstantStringType, Fields);
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002413 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2414 llvm::GlobalVariable::PrivateLinkage, C,
2415 "_unnamed_nsstring_");
2416 // FIXME. Fix section.
Fariborz Jahaniand3fa7012010-04-23 22:33:39 +00002417 if (const char *Sect =
John McCall5fb5df92012-06-20 06:18:46 +00002418 LangOpts.ObjCRuntime.isNonFragile()
Douglas Gregore8bbc122011-09-02 00:18:52 +00002419 ? getContext().getTargetInfo().getNSStringNonFragileABISection()
2420 : getContext().getTargetInfo().getNSStringSection())
Fariborz Jahaniane804c282010-04-23 17:41:07 +00002421 GV->setSection(Sect);
2422 Entry.setValue(GV);
2423
2424 return GV;
Fariborz Jahanian63408e82010-04-22 20:26:39 +00002425}
2426
Douglas Gregor636e2002011-08-09 17:23:49 +00002427QualType CodeGenModule::getObjCFastEnumerationStateType() {
2428 if (ObjCFastEnumerationStateType.isNull()) {
2429 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2430 Context.getTranslationUnitDecl(),
2431 &Context.Idents.get("__objcFastEnumerationState"));
2432 D->startDefinition();
2433
2434 QualType FieldTypes[] = {
2435 Context.UnsignedLongTy,
2436 Context.getPointerType(Context.getObjCIdType()),
2437 Context.getPointerType(Context.UnsignedLongTy),
2438 Context.getConstantArrayType(Context.UnsignedLongTy,
2439 llvm::APInt(32, 5), ArrayType::Normal, 0)
2440 };
2441
2442 for (size_t i = 0; i < 4; ++i) {
2443 FieldDecl *Field = FieldDecl::Create(Context,
2444 D,
2445 SourceLocation(),
2446 SourceLocation(), 0,
2447 FieldTypes[i], /*TInfo=*/0,
2448 /*BitWidth=*/0,
2449 /*Mutable=*/false,
Richard Smith2b013182012-06-10 03:12:00 +00002450 ICIS_NoInit);
Douglas Gregor636e2002011-08-09 17:23:49 +00002451 Field->setAccess(AS_public);
2452 D->addDecl(Field);
2453 }
2454
2455 D->completeDefinition();
2456 ObjCFastEnumerationStateType = Context.getTagDeclType(D);
2457 }
2458
2459 return ObjCFastEnumerationStateType;
2460}
2461
Eli Friedmanfcec6302011-11-01 02:23:42 +00002462llvm::Constant *
2463CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) {
2464 assert(!E->getType()->isPointerType() && "Strings are always arrays");
2465
2466 // Don't emit it as the address of the string, emit the string data itself
2467 // as an inline array.
Chris Lattner00a10ca2012-02-06 22:47:00 +00002468 if (E->getCharByteWidth() == 1) {
2469 SmallString<64> Str(E->getString());
2470
2471 // Resize the string to the right size, which is indicated by its type.
2472 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
2473 Str.resize(CAT->getSize().getZExtValue());
2474 return llvm::ConstantDataArray::getString(VMContext, Str, false);
2475 }
Chris Lattner9c818332012-02-05 02:30:40 +00002476
2477 llvm::ArrayType *AType =
2478 cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
2479 llvm::Type *ElemTy = AType->getElementType();
2480 unsigned NumElements = AType->getNumElements();
Chris Lattner02cb1712012-02-06 22:52:04 +00002481
2482 // Wide strings have either 2-byte or 4-byte elements.
2483 if (ElemTy->getPrimitiveSizeInBits() == 16) {
2484 SmallVector<uint16_t, 32> Elements;
2485 Elements.reserve(NumElements);
2486
2487 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2488 Elements.push_back(E->getCodeUnit(i));
2489 Elements.resize(NumElements);
2490 return llvm::ConstantDataArray::get(VMContext, Elements);
Chris Lattner9c818332012-02-05 02:30:40 +00002491 }
2492
Chris Lattner02cb1712012-02-06 22:52:04 +00002493 assert(ElemTy->getPrimitiveSizeInBits() == 32);
2494 SmallVector<uint32_t, 32> Elements;
2495 Elements.reserve(NumElements);
2496
2497 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2498 Elements.push_back(E->getCodeUnit(i));
2499 Elements.resize(NumElements);
2500 return llvm::ConstantDataArray::get(VMContext, Elements);
Eli Friedmanfcec6302011-11-01 02:23:42 +00002501}
2502
Daniel Dunbarc4baa062008-08-13 23:20:05 +00002503/// GetAddrOfConstantStringFromLiteral - Return a pointer to a
2504/// constant array for the given string literal.
2505llvm::Constant *
2506CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
John McCall9b24df42011-08-04 01:03:22 +00002507 CharUnits Align = getContext().getTypeAlignInChars(S->getType());
Eli Friedmanfcec6302011-11-01 02:23:42 +00002508 if (S->isAscii() || S->isUTF8()) {
Chris Lattner00a10ca2012-02-06 22:47:00 +00002509 SmallString<64> Str(S->getString());
2510
2511 // Resize the string to the right size, which is indicated by its type.
2512 const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType());
2513 Str.resize(CAT->getSize().getZExtValue());
2514 return GetAddrOfConstantString(Str, /*GlobalName*/ 0, Align.getQuantity());
Eli Friedman49ddc5f2009-11-16 05:55:46 +00002515 }
Eli Friedmanfcec6302011-11-01 02:23:42 +00002516
Chris Lattner00a10ca2012-02-06 22:47:00 +00002517 // FIXME: the following does not memoize wide strings.
Eli Friedmanfcec6302011-11-01 02:23:42 +00002518 llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
2519 llvm::GlobalVariable *GV =
2520 new llvm::GlobalVariable(getModule(),C->getType(),
David Blaikiebbafb8a2012-03-11 07:00:24 +00002521 !LangOpts.WritableStrings,
Eli Friedmanfcec6302011-11-01 02:23:42 +00002522 llvm::GlobalValue::PrivateLinkage,
2523 C,".str");
Seth Cantrellc9196652012-01-18 12:11:32 +00002524
Eli Friedmanfcec6302011-11-01 02:23:42 +00002525 GV->setAlignment(Align.getQuantity());
2526 GV->setUnnamedAddr(true);
Eli Friedmanfcec6302011-11-01 02:23:42 +00002527 return GV;
Daniel Dunbarc4baa062008-08-13 23:20:05 +00002528}
2529
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00002530/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
2531/// array for the given ObjCEncodeExpr node.
2532llvm::Constant *
2533CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
2534 std::string Str;
2535 getContext().getObjCEncodingForType(E->getEncodedType(), Str);
Eli Friedman4663a332009-03-07 20:17:55 +00002536
2537 return GetAddrOfConstantCString(Str);
Chris Lattnerd7e7b8e2009-02-24 22:18:39 +00002538}
2539
2540
Chris Lattner36fc8792008-02-11 00:02:17 +00002541/// GenerateWritableString -- Creates storage for a string literal.
John McCall9b24df42011-08-04 01:03:22 +00002542static llvm::GlobalVariable *GenerateStringLiteral(StringRef str,
Chris Lattnerfb300092007-11-28 05:34:05 +00002543 bool constant,
Daniel Dunbardfcf5992008-10-17 21:56:50 +00002544 CodeGenModule &CGM,
John McCall9b24df42011-08-04 01:03:22 +00002545 const char *GlobalName,
2546 unsigned Alignment) {
Daniel Dunbarc4baa062008-08-13 23:20:05 +00002547 // Create Constant for this string literal. Don't add a '\0'.
Owen Anderson41a75022009-08-13 21:57:51 +00002548 llvm::Constant *C =
Chris Lattner9c818332012-02-05 02:30:40 +00002549 llvm::ConstantDataArray::getString(CGM.getLLVMContext(), str, false);
Mike Stump11289f42009-09-09 15:08:12 +00002550
Chris Lattnerfb300092007-11-28 05:34:05 +00002551 // Create a global variable for this string
Rafael Espindolab7f60e32011-01-10 22:34:03 +00002552 llvm::GlobalVariable *GV =
2553 new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
2554 llvm::GlobalValue::PrivateLinkage,
2555 C, GlobalName);
John McCall9b24df42011-08-04 01:03:22 +00002556 GV->setAlignment(Alignment);
Rafael Espindolab7f60e32011-01-10 22:34:03 +00002557 GV->setUnnamedAddr(true);
2558 return GV;
Chris Lattnerfb300092007-11-28 05:34:05 +00002559}
2560
Daniel Dunbarc4baa062008-08-13 23:20:05 +00002561/// GetAddrOfConstantString - Returns a pointer to a character array
2562/// containing the literal. This contents are exactly that of the
2563/// given string, i.e. it will not be null terminated automatically;
2564/// see GetAddrOfConstantCString. Note that whether the result is
2565/// actually a pointer to an LLVM constant depends on
2566/// Feature.WriteableStrings.
2567///
2568/// The result has pointer to array type.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002569llvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str,
John McCall9b24df42011-08-04 01:03:22 +00002570 const char *GlobalName,
2571 unsigned Alignment) {
Daniel Dunbar08b216a2009-03-31 23:42:16 +00002572 // Get the default prefix if a name wasn't specified.
2573 if (!GlobalName)
Chris Lattner3afa3e12009-07-16 05:03:48 +00002574 GlobalName = ".str";
Daniel Dunbar08b216a2009-03-31 23:42:16 +00002575
2576 // Don't share any string literals if strings aren't constant.
David Blaikiebbafb8a2012-03-11 07:00:24 +00002577 if (LangOpts.WritableStrings)
John McCall9b24df42011-08-04 01:03:22 +00002578 return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment);
Mike Stump11289f42009-09-09 15:08:12 +00002579
John McCall9b24df42011-08-04 01:03:22 +00002580 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
Benjamin Kramer0cd19fb2011-03-05 13:45:23 +00002581 ConstantStringMap.GetOrCreateValue(Str);
Chris Lattnerfb300092007-11-28 05:34:05 +00002582
John McCall9b24df42011-08-04 01:03:22 +00002583 if (llvm::GlobalVariable *GV = Entry.getValue()) {
2584 if (Alignment > GV->getAlignment()) {
2585 GV->setAlignment(Alignment);
2586 }
2587 return GV;
2588 }
Chris Lattnerfb300092007-11-28 05:34:05 +00002589
2590 // Create a global variable for this.
Chris Lattner00a10ca2012-02-06 22:47:00 +00002591 llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName,
2592 Alignment);
John McCall9b24df42011-08-04 01:03:22 +00002593 Entry.setValue(GV);
2594 return GV;
Chris Lattnerfb300092007-11-28 05:34:05 +00002595}
Daniel Dunbarc4baa062008-08-13 23:20:05 +00002596
2597/// GetAddrOfConstantCString - Returns a pointer to a character
Benjamin Kramer0cd19fb2011-03-05 13:45:23 +00002598/// array containing the literal and a terminating '\0'
Daniel Dunbarc4baa062008-08-13 23:20:05 +00002599/// character. The result has pointer to array type.
Benjamin Kramer0cd19fb2011-03-05 13:45:23 +00002600llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str,
John McCall9b24df42011-08-04 01:03:22 +00002601 const char *GlobalName,
2602 unsigned Alignment) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002603 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
John McCall9b24df42011-08-04 01:03:22 +00002604 return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment);
Daniel Dunbarc4baa062008-08-13 23:20:05 +00002605}
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002606
Daniel Dunbar89654ee2008-08-26 08:29:31 +00002607/// EmitObjCPropertyImplementations - Emit information for synthesized
2608/// properties for an implementation.
Mike Stump11289f42009-09-09 15:08:12 +00002609void CodeGenModule::EmitObjCPropertyImplementations(const
Daniel Dunbar89654ee2008-08-26 08:29:31 +00002610 ObjCImplementationDecl *D) {
Mike Stump11289f42009-09-09 15:08:12 +00002611 for (ObjCImplementationDecl::propimpl_iterator
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002612 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
David Blaikie40ed2972012-06-06 20:45:41 +00002613 ObjCPropertyImplDecl *PID = *i;
Mike Stump11289f42009-09-09 15:08:12 +00002614
Daniel Dunbar89654ee2008-08-26 08:29:31 +00002615 // Dynamic is just for type-checking.
2616 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
2617 ObjCPropertyDecl *PD = PID->getPropertyDecl();
2618
2619 // Determine which methods need to be implemented, some may have
Jordan Rosed01e83a2012-10-10 16:42:25 +00002620 // been overridden. Note that ::isPropertyAccessor is not the method
Daniel Dunbar89654ee2008-08-26 08:29:31 +00002621 // we want, that just indicates if the decl came from a
2622 // property. What we want to know is if the method is defined in
2623 // this implementation.
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002624 if (!D->getInstanceMethod(PD->getGetterName()))
Fariborz Jahanian3d8552a2008-12-09 20:23:04 +00002625 CodeGenFunction(*this).GenerateObjCGetter(
2626 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbar89654ee2008-08-26 08:29:31 +00002627 if (!PD->isReadOnly() &&
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002628 !D->getInstanceMethod(PD->getSetterName()))
Fariborz Jahanian3d8552a2008-12-09 20:23:04 +00002629 CodeGenFunction(*this).GenerateObjCSetter(
2630 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbar89654ee2008-08-26 08:29:31 +00002631 }
2632 }
2633}
2634
John McCall6a4fa522011-03-22 07:05:39 +00002635static bool needsDestructMethod(ObjCImplementationDecl *impl) {
Jordy Rosea91768e2011-07-22 02:08:32 +00002636 const ObjCInterfaceDecl *iface = impl->getClassInterface();
2637 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
John McCall6a4fa522011-03-22 07:05:39 +00002638 ivar; ivar = ivar->getNextIvar())
2639 if (ivar->getType().isDestructedType())
2640 return true;
2641
2642 return false;
2643}
2644
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002645/// EmitObjCIvarInitializations - Emit information for ivar initialization
2646/// for an implementation.
2647void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
John McCall6a4fa522011-03-22 07:05:39 +00002648 // We might need a .cxx_destruct even if we don't have any ivar initializers.
2649 if (needsDestructMethod(D)) {
2650 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
2651 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
2652 ObjCMethodDecl *DTORMethod =
2653 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
Argyrios Kyrtzidis004df6e2011-08-17 19:25:08 +00002654 cxxSelector, getContext().VoidTy, 0, D,
2655 /*isInstance=*/true, /*isVariadic=*/false,
Jordan Rosed01e83a2012-10-10 16:42:25 +00002656 /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
Argyrios Kyrtzidis004df6e2011-08-17 19:25:08 +00002657 /*isDefined=*/false, ObjCMethodDecl::Required);
John McCall6a4fa522011-03-22 07:05:39 +00002658 D->addInstanceMethod(DTORMethod);
2659 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
John McCall0d54a172012-10-17 04:53:31 +00002660 D->setHasDestructors(true);
John McCall6a4fa522011-03-22 07:05:39 +00002661 }
2662
2663 // If the implementation doesn't have any ivar initializers, we don't need
2664 // a .cxx_construct.
David Chisnalla9e54602011-03-17 14:19:08 +00002665 if (D->getNumIvarInitializers() == 0)
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002666 return;
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002667
John McCall6a4fa522011-03-22 07:05:39 +00002668 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
2669 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002670 // The constructor returns 'self'.
2671 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
2672 D->getLocation(),
Argyrios Kyrtzidisdfd65702011-10-03 06:36:36 +00002673 D->getLocation(),
Argyrios Kyrtzidisdfd65702011-10-03 06:36:36 +00002674 cxxSelector,
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002675 getContext().getObjCIdType(), 0,
Argyrios Kyrtzidis004df6e2011-08-17 19:25:08 +00002676 D, /*isInstance=*/true,
2677 /*isVariadic=*/false,
Jordan Rosed01e83a2012-10-10 16:42:25 +00002678 /*isPropertyAccessor=*/true,
Argyrios Kyrtzidis004df6e2011-08-17 19:25:08 +00002679 /*isImplicitlyDeclared=*/true,
2680 /*isDefined=*/false,
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002681 ObjCMethodDecl::Required);
2682 D->addInstanceMethod(CTORMethod);
2683 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
John McCall0d54a172012-10-17 04:53:31 +00002684 D->setHasNonZeroConstructors(true);
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002685}
2686
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00002687/// EmitNamespace - Emit all declarations in a namespace.
Anders Carlsson237f3492009-04-01 00:58:25 +00002688void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002689 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
Anders Carlsson237f3492009-04-01 00:58:25 +00002690 I != E; ++I)
2691 EmitTopLevelDecl(*I);
2692}
2693
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00002694// EmitLinkageSpec - Emit all declarations in a linkage spec.
2695void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
Eli Friedmane480ce32009-08-01 20:48:04 +00002696 if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
2697 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00002698 ErrorUnsupported(LSD, "linkage spec");
2699 return;
2700 }
2701
Argyrios Kyrtzidiscfbfe782009-06-30 02:36:12 +00002702 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
Fariborz Jahanian2d26c292012-10-26 20:22:11 +00002703 I != E; ++I) {
Fariborz Jahanian9dd2e082012-10-26 22:20:25 +00002704 // Meta-data for ObjC class includes references to implemented methods.
2705 // Generate class's method definitions first.
Fariborz Jahanian2d26c292012-10-26 20:22:11 +00002706 if (ObjCImplDecl *OID = dyn_cast<ObjCImplDecl>(*I)) {
2707 for (ObjCContainerDecl::method_iterator M = OID->meth_begin(),
2708 MEnd = OID->meth_end();
2709 M != MEnd; ++M)
2710 EmitTopLevelDecl(*M);
2711 }
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00002712 EmitTopLevelDecl(*I);
Fariborz Jahanian2d26c292012-10-26 20:22:11 +00002713 }
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00002714}
2715
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002716/// EmitTopLevelDecl - Emit code for a single top level declaration.
2717void CodeGenModule::EmitTopLevelDecl(Decl *D) {
2718 // If an error has occurred, stop code generation, but continue
2719 // parsing and semantic analysis (to ensure all warnings and errors
2720 // are emitted).
2721 if (Diags.hasErrorOccurred())
2722 return;
2723
Douglas Gregor70d83e22009-06-29 17:30:29 +00002724 // Ignore dependent declarations.
2725 if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
2726 return;
Mike Stump11289f42009-09-09 15:08:12 +00002727
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002728 switch (D->getKind()) {
Anders Carlsson6c0a6e42009-08-25 13:14:46 +00002729 case Decl::CXXConversion:
Anders Carlsson468fa632009-04-04 20:47:02 +00002730 case Decl::CXXMethod:
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002731 case Decl::Function:
Douglas Gregor70d83e22009-06-29 17:30:29 +00002732 // Skip function templates
Francois Pichet1c229c02011-04-22 22:18:13 +00002733 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2734 cast<FunctionDecl>(D)->isLateTemplateParsed())
Douglas Gregor70d83e22009-06-29 17:30:29 +00002735 return;
Mike Stump11289f42009-09-09 15:08:12 +00002736
Anders Carlssonecf9bf02009-09-10 23:43:36 +00002737 EmitGlobal(cast<FunctionDecl>(D));
2738 break;
2739
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002740 case Decl::Var:
Anders Carlssonecf9bf02009-09-10 23:43:36 +00002741 EmitGlobal(cast<VarDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002742 break;
2743
John McCall32f44bd2011-04-12 01:01:22 +00002744 // Indirect fields from global anonymous structs and unions can be
2745 // ignored; only the actual variable requires IR gen support.
2746 case Decl::IndirectField:
2747 break;
2748
Anders Carlssonf7475242009-04-15 15:55:24 +00002749 // C++ Decls
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002750 case Decl::Namespace:
Anders Carlsson237f3492009-04-01 00:58:25 +00002751 EmitNamespace(cast<NamespaceDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002752 break;
Douglas Gregorfec52632009-06-20 00:51:54 +00002753 // No code generation needed.
John McCall1e9de052009-11-17 09:33:40 +00002754 case Decl::UsingShadow:
Douglas Gregorfec52632009-06-20 00:51:54 +00002755 case Decl::Using:
Douglas Gregore5feb512009-09-02 23:49:23 +00002756 case Decl::UsingDirective:
Douglas Gregor8f5d4422009-06-29 20:59:39 +00002757 case Decl::ClassTemplate:
2758 case Decl::FunctionTemplate:
Richard Smith3f1b5d02011-05-05 21:57:07 +00002759 case Decl::TypeAliasTemplate:
Anders Carlsson649a17e2009-09-23 19:19:16 +00002760 case Decl::NamespaceAlias:
Douglas Gregor0aa91e02011-06-05 05:04:23 +00002761 case Decl::Block:
Michael Han84324352013-02-22 17:15:32 +00002762 case Decl::Empty:
Douglas Gregorfec52632009-06-20 00:51:54 +00002763 break;
Anders Carlssonf7475242009-04-15 15:55:24 +00002764 case Decl::CXXConstructor:
Anders Carlsson0ade9712009-11-24 05:16:24 +00002765 // Skip function templates
Francois Pichet1c229c02011-04-22 22:18:13 +00002766 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2767 cast<FunctionDecl>(D)->isLateTemplateParsed())
Anders Carlsson0ade9712009-11-24 05:16:24 +00002768 return;
2769
Anders Carlssonf7475242009-04-15 15:55:24 +00002770 EmitCXXConstructors(cast<CXXConstructorDecl>(D));
2771 break;
Anders Carlssoneaa28f72009-04-17 01:58:57 +00002772 case Decl::CXXDestructor:
Francois Pichet1c229c02011-04-22 22:18:13 +00002773 if (cast<FunctionDecl>(D)->isLateTemplateParsed())
2774 return;
Anders Carlssoneaa28f72009-04-17 01:58:57 +00002775 EmitCXXDestructors(cast<CXXDestructorDecl>(D));
2776 break;
Anders Carlsson87835432009-06-11 21:22:55 +00002777
2778 case Decl::StaticAssert:
2779 // Nothing to do.
2780 break;
2781
Anders Carlssonf7475242009-04-15 15:55:24 +00002782 // Objective-C Decls
Mike Stump11289f42009-09-09 15:08:12 +00002783
Fariborz Jahanian3654e652009-03-18 22:33:24 +00002784 // Forward declarations, no (immediate) code generation.
Chris Lattnerd18136a2009-04-01 02:36:43 +00002785 case Decl::ObjCInterface:
Eric Christopherf8378ca2012-07-19 22:22:55 +00002786 case Decl::ObjCCategory:
Chris Lattnerd18136a2009-04-01 02:36:43 +00002787 break;
2788
Douglas Gregorf6102672012-01-01 21:23:57 +00002789 case Decl::ObjCProtocol: {
2790 ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(D);
2791 if (Proto->isThisDeclarationADefinition())
2792 ObjCRuntime->GenerateProtocol(Proto);
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002793 break;
Douglas Gregorf6102672012-01-01 21:23:57 +00002794 }
2795
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002796 case Decl::ObjCCategoryImpl:
Daniel Dunbar89654ee2008-08-26 08:29:31 +00002797 // Categories have properties but don't support synthesize so we
2798 // can ignore them here.
Peter Collingbournee1d20992011-07-27 20:29:46 +00002799 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002800 break;
2801
Daniel Dunbar89654ee2008-08-26 08:29:31 +00002802 case Decl::ObjCImplementation: {
2803 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
2804 EmitObjCPropertyImplementations(OMD);
Fariborz Jahanian0dec1e02010-04-28 21:28:56 +00002805 EmitObjCIvarInitializations(OMD);
Peter Collingbournee1d20992011-07-27 20:29:46 +00002806 ObjCRuntime->GenerateClass(OMD);
Eric Christopher3d19de92012-04-11 05:56:05 +00002807 // Emit global variable debug information.
2808 if (CGDebugInfo *DI = getModuleDebugInfo())
Alexey Samsonov9c1b9f62012-12-03 18:28:12 +00002809 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
2810 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
2811 OMD->getClassInterface()), OMD->getLocation());
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002812 break;
Mike Stump11289f42009-09-09 15:08:12 +00002813 }
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002814 case Decl::ObjCMethod: {
2815 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
2816 // If this is not a prototype, emit the body.
Argyrios Kyrtzidisddcd1322009-06-30 02:35:26 +00002817 if (OMD->getBody())
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002818 CodeGenFunction(*this).GenerateObjCMethod(OMD);
2819 break;
2820 }
Mike Stump11289f42009-09-09 15:08:12 +00002821 case Decl::ObjCCompatibleAlias:
David Chisnall92d436b2012-01-31 18:59:20 +00002822 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002823 break;
2824
Anders Carlssoncbaeb9e2009-04-02 05:55:18 +00002825 case Decl::LinkageSpec:
2826 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002827 break;
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002828
2829 case Decl::FileScopeAsm: {
2830 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002831 StringRef AsmString = AD->getAsmString()->getString();
Mike Stump11289f42009-09-09 15:08:12 +00002832
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002833 const std::string &S = getModule().getModuleInlineAsm();
2834 if (S.empty())
2835 getModule().setModuleInlineAsm(AsmString);
Joerg Sonnenberger8c02a242012-08-10 10:57:52 +00002836 else if (S.end()[-1] == '\n')
Chris Lattner84037d32011-07-23 20:04:25 +00002837 getModule().setModuleInlineAsm(S + AsmString.str());
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002838 else
Benjamin Kramerb11118b2009-12-11 13:33:18 +00002839 getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002840 break;
2841 }
Mike Stump11289f42009-09-09 15:08:12 +00002842
Douglas Gregor6ddfca92013-01-14 17:21:00 +00002843 case Decl::Import: {
2844 ImportDecl *Import = cast<ImportDecl>(D);
2845
2846 // Ignore import declarations that come from imported modules.
2847 if (clang::Module *Owner = Import->getOwningModule()) {
2848 if (getLangOpts().CurrentModule.empty() ||
2849 Owner->getTopLevelModule()->Name == getLangOpts().CurrentModule)
2850 break;
2851 }
2852
Douglas Gregorbc25ff42013-01-14 20:53:57 +00002853 ImportedModules.insert(Import->getImportedModule());
Douglas Gregor6ddfca92013-01-14 17:21:00 +00002854 break;
2855 }
2856
Mike Stump11289f42009-09-09 15:08:12 +00002857 default:
Mike Stump18bb9282009-05-16 07:57:57 +00002858 // Make sure we handled everything we should, every other kind is a
2859 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
2860 // function. Need to recode Decl::Kind to do that easily.
Daniel Dunbarfce4be82008-08-15 23:26:23 +00002861 assert(isa<TypeDecl>(D) && "Unsupported decl kind");
2862 }
2863}
John McCall09ae0322010-07-06 23:57:41 +00002864
2865/// Turns the given pointer into a constant.
2866static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
2867 const void *Ptr) {
2868 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
Chris Lattner2192fe52011-07-18 04:24:23 +00002869 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
John McCall09ae0322010-07-06 23:57:41 +00002870 return llvm::ConstantInt::get(i64, PtrInt);
2871}
2872
2873static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
2874 llvm::NamedMDNode *&GlobalMetadata,
2875 GlobalDecl D,
2876 llvm::GlobalValue *Addr) {
2877 if (!GlobalMetadata)
2878 GlobalMetadata =
2879 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
2880
2881 // TODO: should we report variant information for ctors/dtors?
2882 llvm::Value *Ops[] = {
2883 Addr,
2884 GetPointerConstant(CGM.getLLVMContext(), D.getDecl())
2885 };
Jay Foadea324f12011-04-21 19:59:12 +00002886 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
John McCall09ae0322010-07-06 23:57:41 +00002887}
2888
2889/// Emits metadata nodes associating all the global values in the
2890/// current module with the Decls they came from. This is useful for
2891/// projects using IR gen as a subroutine.
2892///
2893/// Since there's currently no way to associate an MDNode directly
2894/// with an llvm::GlobalValue, we create a global named metadata
2895/// with the name 'clang.global.decl.ptrs'.
2896void CodeGenModule::EmitDeclMetadata() {
2897 llvm::NamedMDNode *GlobalMetadata = 0;
2898
2899 // StaticLocalDeclMap
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002900 for (llvm::DenseMap<GlobalDecl,StringRef>::iterator
John McCall09ae0322010-07-06 23:57:41 +00002901 I = MangledDeclNames.begin(), E = MangledDeclNames.end();
2902 I != E; ++I) {
2903 llvm::GlobalValue *Addr = getModule().getNamedValue(I->second);
2904 EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr);
2905 }
2906}
2907
2908/// Emits metadata nodes for all the local variables in the current
2909/// function.
2910void CodeGenFunction::EmitDeclMetadata() {
2911 if (LocalDeclMap.empty()) return;
2912
2913 llvm::LLVMContext &Context = getLLVMContext();
2914
2915 // Find the unique metadata ID for this name.
2916 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
2917
2918 llvm::NamedMDNode *GlobalMetadata = 0;
2919
2920 for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator
2921 I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) {
2922 const Decl *D = I->first;
2923 llvm::Value *Addr = I->second;
2924
2925 if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
2926 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
Jay Foadea324f12011-04-21 19:59:12 +00002927 Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr));
John McCall09ae0322010-07-06 23:57:41 +00002928 } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
2929 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
2930 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
2931 }
2932 }
2933}
Daniel Dunbar900546d2010-07-16 00:00:15 +00002934
Nick Lewycky85c011d2011-05-05 00:08:20 +00002935void CodeGenModule::EmitCoverageFile() {
2936 if (!getCodeGenOpts().CoverageFile.empty()) {
Nick Lewycky480cb992011-05-04 20:46:58 +00002937 if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) {
2938 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
2939 llvm::LLVMContext &Ctx = TheModule.getContext();
Nick Lewycky85c011d2011-05-05 00:08:20 +00002940 llvm::MDString *CoverageFile =
2941 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile);
Nick Lewycky480cb992011-05-04 20:46:58 +00002942 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
2943 llvm::MDNode *CU = CUNode->getOperand(i);
Nick Lewycky85c011d2011-05-05 00:08:20 +00002944 llvm::Value *node[] = { CoverageFile, CU };
Nick Lewycky480cb992011-05-04 20:46:58 +00002945 llvm::MDNode *N = llvm::MDNode::get(Ctx, node);
2946 GCov->addOperand(N);
2947 }
2948 }
2949 }
2950}
Nico Webercf4ff5862012-10-11 10:13:44 +00002951
2952llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid,
2953 QualType GuidType) {
2954 // Sema has checked that all uuid strings are of the form
2955 // "12345678-1234-1234-1234-1234567890ab".
2956 assert(Uuid.size() == 36);
2957 const char *Uuidstr = Uuid.data();
2958 for (int i = 0; i < 36; ++i) {
2959 if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuidstr[i] == '-');
Jordan Rosea7d03842013-02-08 22:30:41 +00002960 else assert(isHexDigit(Uuidstr[i]));
Nico Webercf4ff5862012-10-11 10:13:44 +00002961 }
2962
2963 llvm::APInt Field0(32, StringRef(Uuidstr , 8), 16);
2964 llvm::APInt Field1(16, StringRef(Uuidstr + 9, 4), 16);
2965 llvm::APInt Field2(16, StringRef(Uuidstr + 14, 4), 16);
Nico Weber92724072012-10-17 00:34:34 +00002966 static const int Field3ValueOffsets[] = { 19, 21, 24, 26, 28, 30, 32, 34 };
Nico Webercf4ff5862012-10-11 10:13:44 +00002967
2968 APValue InitStruct(APValue::UninitStruct(), /*NumBases=*/0, /*NumFields=*/4);
2969 InitStruct.getStructField(0) = APValue(llvm::APSInt(Field0));
2970 InitStruct.getStructField(1) = APValue(llvm::APSInt(Field1));
2971 InitStruct.getStructField(2) = APValue(llvm::APSInt(Field2));
2972 APValue& Arr = InitStruct.getStructField(3);
2973 Arr = APValue(APValue::UninitArray(), 8, 8);
2974 for (int t = 0; t < 8; ++t)
Nico Webercc51c2f2012-10-13 21:56:05 +00002975 Arr.getArrayInitializedElt(t) = APValue(llvm::APSInt(
2976 llvm::APInt(8, StringRef(Uuidstr + Field3ValueOffsets[t], 2), 16)));
Nico Webercf4ff5862012-10-11 10:13:44 +00002977
2978 return EmitConstantValue(InitStruct, GuidType);
2979}