blob: 9b6d3a50e92689f76799cb1d12cdc2c356ede85b [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This coordinates the per-module state used while generating code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenModule.h"
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +000015#include "CGCUDARuntime.h"
John McCall4c40d982010-08-31 07:33:07 +000016#include "CGCXXABI.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000017#include "CGCall.h"
18#include "CGDebugInfo.h"
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +000019#include "CGObjCRuntime.h"
Peter Collingbourne8c25fc52011-09-19 21:14:35 +000020#include "CGOpenCLRuntime.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000021#include "CodeGenFunction.h"
22#include "CodeGenTBAA.h"
Anton Korobeynikov82d0a412010-01-10 12:58:08 +000023#include "TargetInfo.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000024#include "clang/AST/ASTContext.h"
Ken Dyck687cc4a2010-01-26 13:48:07 +000025#include "clang/AST/CharUnits.h"
Chris Lattner21ef7ae2008-11-04 16:51:42 +000026#include "clang/AST/DeclCXX.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000027#include "clang/AST/DeclObjC.h"
Douglas Gregoraf896892010-06-21 18:41:26 +000028#include "clang/AST/DeclTemplate.h"
Peter Collingbourne14110472011-01-13 18:57:25 +000029#include "clang/AST/Mangle.h"
Anders Carlsson1a5e0d72009-11-30 23:41:22 +000030#include "clang/AST/RecordLayout.h"
Rafael Espindolaa411d2f2011-10-26 20:41:06 +000031#include "clang/AST/RecursiveASTVisitor.h"
Rafael Espindolabcf6b982011-12-19 14:41:01 +000032#include "clang/Basic/Builtins.h"
Jordan Rose3f6f51e2013-02-08 22:30:41 +000033#include "clang/Basic/CharInfo.h"
Chris Lattner2c8569d2007-12-02 07:19:18 +000034#include "clang/Basic/Diagnostic.h"
Douglas Gregorb6cbe512013-01-14 17:21:00 +000035#include "clang/Basic/Module.h"
Nate Begeman8bd4afe2008-04-19 04:17:09 +000036#include "clang/Basic/SourceManager.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000037#include "clang/Basic/TargetInfo.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000038#include "clang/Frontend/CodeGenOptions.h"
Sebastian Redl19b1a6e2012-02-25 20:51:20 +000039#include "llvm/ADT/APSInt.h"
John McCall6374c332010-03-06 00:35:14 +000040#include "llvm/ADT/Triple.h"
Chandler Carruth3b844ba2013-01-02 11:45:17 +000041#include "llvm/IR/CallingConv.h"
42#include "llvm/IR/DataLayout.h"
43#include "llvm/IR/Intrinsics.h"
44#include "llvm/IR/LLVMContext.h"
45#include "llvm/IR/Module.h"
Gabor Greif6ba728d2010-04-10 02:56:12 +000046#include "llvm/Support/CallSite.h"
Dmitri Gribenkocb5620c2013-01-30 12:06:08 +000047#include "llvm/Support/ConvertUTF.h"
Chris Lattner78f7ece2009-11-07 09:22:46 +000048#include "llvm/Support/ErrorHandling.h"
Chandler Carruth55fc8732012-12-04 09:13:33 +000049#include "llvm/Target/Mangler.h"
Dmitri Gribenkocb5620c2013-01-30 12:06:08 +000050
Reid Spencer5f016e22007-07-11 17:01:13 +000051using namespace clang;
52using namespace CodeGen;
53
Julien Lerouge77f68bb2011-09-09 22:41:49 +000054static const char AnnotationSection[] = "llvm.metadata";
55
John McCallf16aa102010-08-22 21:01:12 +000056static CGCXXABI &createCXXABI(CodeGenModule &CGM) {
John McCall64aa4b32013-04-16 22:48:15 +000057 switch (CGM.getTarget().getCXXABI().getKind()) {
Tim Northoverc264e162013-01-31 12:13:10 +000058 case TargetCXXABI::GenericAArch64:
John McCall96fcde02013-01-25 23:36:14 +000059 case TargetCXXABI::GenericARM:
60 case TargetCXXABI::iOS:
61 case TargetCXXABI::GenericItanium:
62 return *CreateItaniumCXXABI(CGM);
63 case TargetCXXABI::Microsoft:
64 return *CreateMicrosoftCXXABI(CGM);
John McCallf16aa102010-08-22 21:01:12 +000065 }
66
67 llvm_unreachable("invalid C++ ABI kind");
John McCallf16aa102010-08-22 21:01:12 +000068}
69
Chandler Carruth2811ccf2009-11-12 17:24:48 +000070CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
John McCall3abae092013-04-16 22:48:20 +000071 llvm::Module &M, const llvm::DataLayout &TD,
David Blaikied6471f72011-09-25 23:23:43 +000072 DiagnosticsEngine &diags)
Alexey Samsonov6a4c5dc2013-08-12 11:48:05 +000073 : Context(C), LangOpts(C.getLangOpts()), CodeGenOpts(CGO), TheModule(M),
74 Diags(diags), TheDataLayout(TD), Target(C.getTargetInfo()),
75 ABI(createCXXABI(*this)), VMContext(M.getContext()), TBAA(0),
76 TheTargetCodeGenInfo(0), Types(*this), VTables(*this), ObjCRuntime(0),
77 OpenCLRuntime(0), CUDARuntime(0), DebugInfo(0), ARCData(0),
78 NoObjCARCExceptionsMetadata(0), RRData(0), CFConstantStringClassRef(0),
79 ConstantStringClassRef(0), NSConstantStringType(0),
80 NSConcreteGlobalBlock(0), NSConcreteStackBlock(0), BlockObjectAssign(0),
81 BlockObjectDispose(0), BlockDescriptorType(0), GenericBlockLiteralType(0),
82 LifetimeStartFn(0), LifetimeEndFn(0),
83 SanitizerBlacklist(
84 llvm::SpecialCaseList::createOrDie(CGO.SanitizerBlacklistFile)),
85 SanOpts(SanitizerBlacklist->isIn(M) ? SanitizerOptions::Disabled
86 : LangOpts.Sanitize) {
Will Dietz4f45bc02013-01-18 11:30:38 +000087
Chris Lattner8b418682012-02-07 00:39:47 +000088 // Initialize the type cache.
89 llvm::LLVMContext &LLVMContext = M.getContext();
90 VoidTy = llvm::Type::getVoidTy(LLVMContext);
91 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
92 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
93 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
94 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
95 FloatTy = llvm::Type::getFloatTy(LLVMContext);
96 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
97 PointerWidthInBits = C.getTargetInfo().getPointerWidth(0);
98 PointerAlignInBytes =
99 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
100 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
101 IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits);
102 Int8PtrTy = Int8Ty->getPointerTo(0);
103 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
104
John McCallbd7370a2013-02-28 19:01:20 +0000105 RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC();
106
David Blaikie4e4d0842012-03-11 07:00:24 +0000107 if (LangOpts.ObjC1)
Peter Collingbourne8c25fc52011-09-19 21:14:35 +0000108 createObjCRuntime();
David Blaikie4e4d0842012-03-11 07:00:24 +0000109 if (LangOpts.OpenCL)
Peter Collingbourne8c25fc52011-09-19 21:14:35 +0000110 createOpenCLRuntime();
David Blaikie4e4d0842012-03-11 07:00:24 +0000111 if (LangOpts.CUDA)
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +0000112 createCUDARuntime();
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +0000113
Kostya Serebryanyc9fe6052012-04-24 06:57:01 +0000114 // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
Will Dietz4f45bc02013-01-18 11:30:38 +0000115 if (SanOpts.Thread ||
Kostya Serebryanyc9fe6052012-04-24 06:57:01 +0000116 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
117 TBAA = new CodeGenTBAA(Context, VMContext, CodeGenOpts, getLangOpts(),
Dan Gohman0b5c4fc2010-10-15 20:23:12 +0000118 ABI.getMangleContext());
Dan Gohman3d5aff52010-10-14 23:06:10 +0000119
Nick Lewyckye8ba8d72011-04-21 23:44:07 +0000120 // If debug info or coverage generation is enabled, create the CGDebugInfo
121 // object.
Douglas Gregor4cdad312012-10-23 20:05:01 +0000122 if (CodeGenOpts.getDebugInfo() != CodeGenOptions::NoDebugInfo ||
Alexey Samsonov3a70cd62012-04-27 07:24:20 +0000123 CodeGenOpts.EmitGcovArcs ||
Nick Lewyckye8ba8d72011-04-21 23:44:07 +0000124 CodeGenOpts.EmitGcovNotes)
125 DebugInfo = new CGDebugInfo(*this);
John McCalld16c2cf2011-02-08 08:22:06 +0000126
127 Block.GlobalUniqueCount = 0;
John McCall5936e332011-02-15 09:22:45 +0000128
David Blaikie4e4d0842012-03-11 07:00:24 +0000129 if (C.getLangOpts().ObjCAutoRefCount)
John McCallf85e1932011-06-15 23:02:42 +0000130 ARCData = new ARCEntrypoints();
131 RRData = new RREntrypoints();
Chris Lattner2b94fe32008-03-01 08:45:05 +0000132}
133
134CodeGenModule::~CodeGenModule() {
Peter Collingbournee9265232011-07-27 20:29:46 +0000135 delete ObjCRuntime;
Peter Collingbourne8c25fc52011-09-19 21:14:35 +0000136 delete OpenCLRuntime;
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +0000137 delete CUDARuntime;
Ted Kremenek0628b722011-10-08 05:28:26 +0000138 delete TheTargetCodeGenInfo;
John McCallf16aa102010-08-22 21:01:12 +0000139 delete &ABI;
Dan Gohman4376c852010-10-15 18:04:46 +0000140 delete TBAA;
Ted Kremenek815c78f2008-08-05 18:50:11 +0000141 delete DebugInfo;
John McCallf85e1932011-06-15 23:02:42 +0000142 delete ARCData;
143 delete RRData;
Ted Kremenek815c78f2008-08-05 18:50:11 +0000144}
145
David Chisnall0d13f6f2010-01-23 02:40:42 +0000146void CodeGenModule::createObjCRuntime() {
John McCall260611a2012-06-20 06:18:46 +0000147 // This is just isGNUFamily(), but we want to force implementors of
148 // new ABIs to decide how best to do this.
149 switch (LangOpts.ObjCRuntime.getKind()) {
David Chisnall11d3f4c2012-07-03 20:49:52 +0000150 case ObjCRuntime::GNUstep:
151 case ObjCRuntime::GCC:
John McCallf7226fb2012-07-12 02:07:58 +0000152 case ObjCRuntime::ObjFW:
Peter Collingbournee9265232011-07-27 20:29:46 +0000153 ObjCRuntime = CreateGNUObjCRuntime(*this);
John McCall260611a2012-06-20 06:18:46 +0000154 return;
155
156 case ObjCRuntime::FragileMacOSX:
157 case ObjCRuntime::MacOSX:
158 case ObjCRuntime::iOS:
Peter Collingbournee9265232011-07-27 20:29:46 +0000159 ObjCRuntime = CreateMacObjCRuntime(*this);
John McCall260611a2012-06-20 06:18:46 +0000160 return;
161 }
162 llvm_unreachable("bad runtime kind");
David Chisnall0d13f6f2010-01-23 02:40:42 +0000163}
164
Peter Collingbourne8c25fc52011-09-19 21:14:35 +0000165void CodeGenModule::createOpenCLRuntime() {
166 OpenCLRuntime = new CGOpenCLRuntime(*this);
167}
168
Peter Collingbourne6c0aa5f2011-10-06 18:29:37 +0000169void CodeGenModule::createCUDARuntime() {
170 CUDARuntime = CreateNVCUDARuntime(*this);
171}
172
Ted Kremenek815c78f2008-08-05 18:50:11 +0000173void CodeGenModule::Release() {
Chris Lattner82227ff2009-03-22 21:21:57 +0000174 EmitDeferred();
Eli Friedman6c6bda32010-01-08 00:50:11 +0000175 EmitCXXGlobalInitFunc();
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000176 EmitCXXGlobalDtorFunc();
Richard Smithb80a16e2013-04-19 16:42:07 +0000177 EmitCXXThreadLocalInitFunc();
Peter Collingbournee9265232011-07-27 20:29:46 +0000178 if (ObjCRuntime)
179 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
Daniel Dunbar208ff5e2008-08-11 18:12:00 +0000180 AddGlobalCtor(ObjCInitFunction);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000181 EmitCtorList(GlobalCtors, "llvm.global_ctors");
182 EmitCtorList(GlobalDtors, "llvm.global_dtors");
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000183 EmitGlobalAnnotations();
Richard Smith00249372013-04-06 05:00:46 +0000184 EmitStaticExternCAliases();
Daniel Dunbar02698712009-02-13 20:29:50 +0000185 EmitLLVMUsed();
Douglas Gregorf43b7212013-01-16 01:23:41 +0000186
Reid Kleckner3190ca92013-05-08 13:44:39 +0000187 if (CodeGenOpts.Autolink &&
188 (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
Douglas Gregorf43b7212013-01-16 01:23:41 +0000189 EmitModuleLinkOptions();
190 }
Manman Renfc0f91c2013-06-19 01:46:49 +0000191 if (CodeGenOpts.DwarfVersion)
192 // We actually want the latest version when there are conflicts.
193 // We can change from Warning to Latest if such mode is supported.
194 getModule().addModuleFlag(llvm::Module::Warning, "Dwarf Version",
195 CodeGenOpts.DwarfVersion);
Douglas Gregor5d75ea72013-01-14 18:28:43 +0000196
John McCallb2593832010-09-16 06:16:50 +0000197 SimplifyPersonality();
198
John McCall744016d2010-07-06 23:57:41 +0000199 if (getCodeGenOpts().EmitDeclMetadata)
200 EmitDeclMetadata();
Nick Lewycky5ea4f442011-05-04 20:46:58 +0000201
202 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
Nick Lewycky3dc05412011-05-05 00:08:20 +0000203 EmitCoverageFile();
Devang Patelf391dbe2011-08-16 20:58:22 +0000204
205 if (DebugInfo)
206 DebugInfo->finalize();
Daniel Dunbarf1968f22008-10-01 00:49:24 +0000207}
208
Devang Patele80d5672011-03-23 16:29:39 +0000209void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
210 // Make sure that this type is translated.
211 Types.UpdateCompletedType(TD);
Devang Patele80d5672011-03-23 16:29:39 +0000212}
213
Dan Gohman3d5aff52010-10-14 23:06:10 +0000214llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) {
215 if (!TBAA)
216 return 0;
217 return TBAA->getTBAAInfo(QTy);
218}
219
Kostya Serebryany8cb4a072012-03-26 17:03:51 +0000220llvm::MDNode *CodeGenModule::getTBAAInfoForVTablePtr() {
221 if (!TBAA)
222 return 0;
223 return TBAA->getTBAAInfoForVTablePtr();
224}
225
Dan Gohmanb22c7dc2012-09-28 21:58:29 +0000226llvm::MDNode *CodeGenModule::getTBAAStructInfo(QualType QTy) {
227 if (!TBAA)
228 return 0;
229 return TBAA->getTBAAStructInfo(QTy);
230}
231
Manman Renb37a73d2013-04-04 21:53:22 +0000232llvm::MDNode *CodeGenModule::getTBAAStructTypeInfo(QualType QTy) {
233 if (!TBAA)
234 return 0;
235 return TBAA->getTBAAStructTypeInfo(QTy);
236}
237
238llvm::MDNode *CodeGenModule::getTBAAStructTagInfo(QualType BaseTy,
239 llvm::MDNode *AccessN,
240 uint64_t O) {
241 if (!TBAA)
242 return 0;
243 return TBAA->getTBAAStructTagInfo(BaseTy, AccessN, O);
244}
245
Manman Renca835182013-04-11 23:02:56 +0000246/// Decorate the instruction with a TBAA tag. For scalar TBAA, the tag
247/// is the same as the type. For struct-path aware TBAA, the tag
248/// is different from the type: base type, access type and offset.
249/// When ConvertTypeToTag is true, we create a tag based on the scalar type.
Dan Gohman3d5aff52010-10-14 23:06:10 +0000250void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst,
Manman Renca835182013-04-11 23:02:56 +0000251 llvm::MDNode *TBAAInfo,
252 bool ConvertTypeToTag) {
253 if (ConvertTypeToTag && TBAA && CodeGenOpts.StructPathTBAA)
254 Inst->setMetadata(llvm::LLVMContext::MD_tbaa,
255 TBAA->getTBAAScalarTagInfo(TBAAInfo));
256 else
257 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo);
Dan Gohman3d5aff52010-10-14 23:06:10 +0000258}
259
Chandler Carruth0f30a122012-03-30 19:44:53 +0000260void CodeGenModule::Error(SourceLocation loc, StringRef error) {
261 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, error);
John McCall32096692011-03-18 02:56:14 +0000262 getDiags().Report(Context.getFullLoc(loc), diagID);
263}
264
Daniel Dunbar488e9932008-08-16 00:56:44 +0000265/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattner2c8569d2007-12-02 07:19:18 +0000266/// specified stmt yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000267void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
268 bool OmitOnError) {
269 if (OmitOnError && getDiags().hasErrorOccurred())
270 return;
David Blaikied6471f72011-09-25 23:23:43 +0000271 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
Daniel Dunbar56b80012009-02-06 19:18:03 +0000272 "cannot compile this %0 yet");
Chris Lattner2c8569d2007-12-02 07:19:18 +0000273 std::string Msg = Type;
Chris Lattner0a14eee2008-11-18 07:04:44 +0000274 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
275 << Msg << S->getSourceRange();
Chris Lattner2c8569d2007-12-02 07:19:18 +0000276}
Chris Lattner58c3f9e2007-12-02 06:27:33 +0000277
Daniel Dunbar488e9932008-08-16 00:56:44 +0000278/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000279/// specified decl yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000280void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
281 bool OmitOnError) {
282 if (OmitOnError && getDiags().hasErrorOccurred())
283 return;
David Blaikied6471f72011-09-25 23:23:43 +0000284 unsigned DiagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error,
Daniel Dunbar56b80012009-02-06 19:18:03 +0000285 "cannot compile this %0 yet");
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000286 std::string Msg = Type;
Chris Lattner0a14eee2008-11-18 07:04:44 +0000287 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000288}
289
John McCallbc8d40d2011-06-24 21:55:10 +0000290llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
291 return llvm::ConstantInt::get(SizeTy, size.getQuantity());
292}
293
Mike Stump1eb44332009-09-09 15:08:12 +0000294void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
Anders Carlsson0ffeaad2011-01-29 19:39:23 +0000295 const NamedDecl *D) const {
Daniel Dunbar04d40782009-04-14 06:00:08 +0000296 // Internal definitions always have default visibility.
Chris Lattnerdf102fc2009-04-14 05:27:13 +0000297 if (GV->hasLocalLinkage()) {
Daniel Dunbar7e714cd2009-04-10 20:26:50 +0000298 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar6ab187a2009-04-07 05:48:37 +0000299 return;
Daniel Dunbar7e714cd2009-04-10 20:26:50 +0000300 }
Daniel Dunbar6ab187a2009-04-07 05:48:37 +0000301
John McCallaf146032010-10-30 11:50:40 +0000302 // Set visibility for definitions.
Rafael Espindola2beda122013-02-27 02:15:29 +0000303 LinkageInfo LV = D->getLinkageAndVisibility();
Rafael Espindolaf127eb82013-02-27 02:56:45 +0000304 if (LV.isVisibilityExplicit() || !GV->hasAvailableExternallyLinkage())
305 GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
Dan Gohman4f8d1232008-05-22 00:50:06 +0000306}
307
Hans Wennborgde981f32012-06-28 08:01:44 +0000308static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
309 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
310 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
311 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
312 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
313 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
314}
315
316static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(
317 CodeGenOptions::TLSModel M) {
318 switch (M) {
319 case CodeGenOptions::GeneralDynamicTLSModel:
320 return llvm::GlobalVariable::GeneralDynamicTLSModel;
321 case CodeGenOptions::LocalDynamicTLSModel:
322 return llvm::GlobalVariable::LocalDynamicTLSModel;
323 case CodeGenOptions::InitialExecTLSModel:
324 return llvm::GlobalVariable::InitialExecTLSModel;
325 case CodeGenOptions::LocalExecTLSModel:
326 return llvm::GlobalVariable::LocalExecTLSModel;
327 }
328 llvm_unreachable("Invalid TLS model!");
329}
330
331void CodeGenModule::setTLSMode(llvm::GlobalVariable *GV,
332 const VarDecl &D) const {
Richard Smith38afbc72013-04-13 02:43:54 +0000333 assert(D.getTLSKind() && "setting TLS mode on non-TLS var!");
Hans Wennborgde981f32012-06-28 08:01:44 +0000334
335 llvm::GlobalVariable::ThreadLocalMode TLM;
Douglas Gregor4cdad312012-10-23 20:05:01 +0000336 TLM = GetLLVMTLSModel(CodeGenOpts.getDefaultTLSModel());
Hans Wennborgde981f32012-06-28 08:01:44 +0000337
338 // Override the TLS model if it is explicitly specified.
339 if (D.hasAttr<TLSModelAttr>()) {
340 const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>();
341 TLM = GetLLVMTLSModel(Attr->getModel());
342 }
343
344 GV->setThreadLocalMode(TLM);
345}
346
John McCallcbfe5022010-08-04 08:34:44 +0000347/// Set the symbol visibility of type information (vtable and RTTI)
348/// associated with the given type.
349void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV,
350 const CXXRecordDecl *RD,
Anders Carlssonfa2e99f2011-01-29 20:24:48 +0000351 TypeVisibilityKind TVK) const {
Anders Carlsson0ffeaad2011-01-29 19:39:23 +0000352 setGlobalVisibility(GV, RD);
John McCallcbfe5022010-08-04 08:34:44 +0000353
John McCall279b5eb2010-08-12 23:36:15 +0000354 if (!CodeGenOpts.HiddenWeakVTables)
355 return;
356
Anders Carlsson9a86a132011-01-29 20:36:11 +0000357 // We never want to drop the visibility for RTTI names.
358 if (TVK == TVK_ForRTTIName)
359 return;
360
John McCallcbfe5022010-08-04 08:34:44 +0000361 // We want to drop the visibility to hidden for weak type symbols.
362 // This isn't possible if there might be unresolved references
363 // elsewhere that rely on this symbol being visible.
364
John McCall7a536902010-08-05 20:39:18 +0000365 // This should be kept roughly in sync with setThunkVisibility
366 // in CGVTables.cpp.
367
John McCallcbfe5022010-08-04 08:34:44 +0000368 // Preconditions.
Anders Carlssonf502d932011-01-24 00:46:19 +0000369 if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage ||
John McCallcbfe5022010-08-04 08:34:44 +0000370 GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
371 return;
372
373 // Don't override an explicit visibility attribute.
John McCalld4c3d662013-02-20 01:54:26 +0000374 if (RD->getExplicitVisibility(NamedDecl::VisibilityForType))
John McCallcbfe5022010-08-04 08:34:44 +0000375 return;
376
377 switch (RD->getTemplateSpecializationKind()) {
378 // We have to disable the optimization if this is an EI definition
379 // because there might be EI declarations in other shared objects.
380 case TSK_ExplicitInstantiationDefinition:
381 case TSK_ExplicitInstantiationDeclaration:
382 return;
383
John McCall7a536902010-08-05 20:39:18 +0000384 // Every use of a non-template class's type information has to emit it.
John McCallcbfe5022010-08-04 08:34:44 +0000385 case TSK_Undeclared:
386 break;
387
John McCall7a536902010-08-05 20:39:18 +0000388 // In theory, implicit instantiations can ignore the possibility of
389 // an explicit instantiation declaration because there necessarily
390 // must be an EI definition somewhere with default visibility. In
391 // practice, it's possible to have an explicit instantiation for
392 // an arbitrary template class, and linkers aren't necessarily able
393 // to deal with mixed-visibility symbols.
394 case TSK_ExplicitSpecialization:
John McCallcbfe5022010-08-04 08:34:44 +0000395 case TSK_ImplicitInstantiation:
Douglas Gregoraafd1112012-10-24 14:11:55 +0000396 return;
John McCallcbfe5022010-08-04 08:34:44 +0000397 }
398
399 // If there's a key function, there may be translation units
400 // that don't have the key function's definition. But ignore
401 // this if we're emitting RTTI under -fno-rtti.
David Blaikie4e4d0842012-03-11 07:00:24 +0000402 if (!(TVK != TVK_ForRTTI) || LangOpts.RTTI) {
John McCalld5617ee2013-01-25 22:31:03 +0000403 // FIXME: what should we do if we "lose" the key function during
404 // the emission of the file?
405 if (Context.getCurrentKeyFunction(RD))
John McCallcbfe5022010-08-04 08:34:44 +0000406 return;
Anders Carlssonfa2e99f2011-01-29 20:24:48 +0000407 }
John McCallcbfe5022010-08-04 08:34:44 +0000408
409 // Otherwise, drop the visibility to hidden.
410 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Rafael Espindolab1c65ff2011-01-11 21:44:37 +0000411 GV->setUnnamedAddr(true);
John McCallcbfe5022010-08-04 08:34:44 +0000412}
413
Chris Lattner5f9e2722011-07-23 10:55:15 +0000414StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
Anders Carlsson793a9902010-06-22 16:05:32 +0000415 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
416
Chris Lattner5f9e2722011-07-23 10:55:15 +0000417 StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()];
Anders Carlsson793a9902010-06-22 16:05:32 +0000418 if (!Str.empty())
419 return Str;
420
John McCall4c40d982010-08-31 07:33:07 +0000421 if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
Anders Carlsson793a9902010-06-22 16:05:32 +0000422 IdentifierInfo *II = ND->getIdentifier();
423 assert(II && "Attempt to mangle unnamed decl.");
424
425 Str = II->getName();
426 return Str;
427 }
428
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000429 SmallString<256> Buffer;
Rafael Espindolac4850c22011-02-10 23:59:36 +0000430 llvm::raw_svector_ostream Out(Buffer);
Anders Carlsson793a9902010-06-22 16:05:32 +0000431 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000432 getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000433 else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000434 getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000435 else
Rafael Espindolac4850c22011-02-10 23:59:36 +0000436 getCXXABI().getMangleContext().mangleName(ND, Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000437
438 // Allocate space for the mangled name.
Rafael Espindolac4850c22011-02-10 23:59:36 +0000439 Out.flush();
Anders Carlsson793a9902010-06-22 16:05:32 +0000440 size_t Length = Buffer.size();
441 char *Name = MangledNamesAllocator.Allocate<char>(Length);
442 std::copy(Buffer.begin(), Buffer.end(), Name);
443
Chris Lattner5f9e2722011-07-23 10:55:15 +0000444 Str = StringRef(Name, Length);
Anders Carlsson793a9902010-06-22 16:05:32 +0000445
446 return Str;
447}
448
Peter Collingbourne14110472011-01-13 18:57:25 +0000449void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer,
450 const BlockDecl *BD) {
451 MangleContext &MangleCtx = getCXXABI().getMangleContext();
452 const Decl *D = GD.getDecl();
Rafael Espindolac4850c22011-02-10 23:59:36 +0000453 llvm::raw_svector_ostream Out(Buffer.getBuffer());
Peter Collingbourne14110472011-01-13 18:57:25 +0000454 if (D == 0)
Fariborz Jahanian4904bf42012-06-26 16:06:38 +0000455 MangleCtx.mangleGlobalBlock(BD,
456 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
Peter Collingbourne14110472011-01-13 18:57:25 +0000457 else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000458 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
Peter Collingbourne14110472011-01-13 18:57:25 +0000459 else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000460 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
Peter Collingbourne14110472011-01-13 18:57:25 +0000461 else
Rafael Espindolac4850c22011-02-10 23:59:36 +0000462 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
Anders Carlsson9a8822b2010-06-09 02:36:32 +0000463}
464
Chris Lattner5f9e2722011-07-23 10:55:15 +0000465llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
John McCallf746aa62010-03-19 23:29:14 +0000466 return getModule().getNamedValue(Name);
Douglas Gregor5f2bfd42009-02-13 00:10:09 +0000467}
468
Chris Lattner6d397602008-03-14 17:18:18 +0000469/// AddGlobalCtor - Add a function to the list that will be called before
470/// main() runs.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000471void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
Daniel Dunbar49988882009-01-13 02:25:00 +0000472 // FIXME: Type coercion of void()* types.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000473 GlobalCtors.push_back(std::make_pair(Ctor, Priority));
Chris Lattner6d397602008-03-14 17:18:18 +0000474}
475
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000476/// AddGlobalDtor - Add a function to the list that will be called
477/// when the module is unloaded.
478void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
Daniel Dunbar49988882009-01-13 02:25:00 +0000479 // FIXME: Type coercion of void()* types.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000480 GlobalDtors.push_back(std::make_pair(Dtor, Priority));
481}
482
483void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
484 // Ctor function type is void()*.
John McCall0774cb82011-05-15 01:53:33 +0000485 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000486 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000487
488 // Get the type of a ctor entry, { i32, void ()* }.
Chris Lattnerc5cbb902011-06-20 04:01:35 +0000489 llvm::StructType *CtorStructTy =
Chris Lattner8b418682012-02-07 00:39:47 +0000490 llvm::StructType::get(Int32Ty, llvm::PointerType::getUnqual(CtorFTy), NULL);
Chris Lattner6d397602008-03-14 17:18:18 +0000491
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000492 // Construct the constructor and destructor arrays.
Chris Lattner0b239712012-02-06 22:16:34 +0000493 SmallVector<llvm::Constant*, 8> Ctors;
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000494 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
Chris Lattner0b239712012-02-06 22:16:34 +0000495 llvm::Constant *S[] = {
496 llvm::ConstantInt::get(Int32Ty, I->second, false),
497 llvm::ConstantExpr::getBitCast(I->first, CtorPFTy)
498 };
Owen Anderson08e25242009-07-27 22:29:56 +0000499 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
Chris Lattner6d397602008-03-14 17:18:18 +0000500 }
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000501
502 if (!Ctors.empty()) {
Owen Anderson96e0fc72009-07-29 22:16:19 +0000503 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
Owen Anderson1c431b32009-07-08 19:05:04 +0000504 new llvm::GlobalVariable(TheModule, AT, false,
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000505 llvm::GlobalValue::AppendingLinkage,
Owen Anderson7db6d832009-07-28 18:33:04 +0000506 llvm::ConstantArray::get(AT, Ctors),
Owen Anderson1c431b32009-07-08 19:05:04 +0000507 GlobalName);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000508 }
Chris Lattner6d397602008-03-14 17:18:18 +0000509}
510
John McCalld46f9852010-02-19 01:32:20 +0000511llvm::GlobalValue::LinkageTypes
Peter Collingbourne144a31f2013-06-05 17:49:37 +0000512CodeGenModule::getFunctionLinkage(GlobalDecl GD) {
Eli Friedman7a36a592013-07-01 20:53:07 +0000513 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
Reid Klecknera4130ba2013-07-22 13:51:44 +0000514
515 if (isa<CXXDestructorDecl>(D) &&
516 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
517 GD.getDtorType()))
518 return llvm::Function::LinkOnceODRLinkage;
519
Argyrios Kyrtzidis90e99a82010-07-29 18:15:58 +0000520 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000521
Chris Lattnerf81530652010-06-30 16:58:07 +0000522 if (Linkage == GVA_Internal)
John McCalld46f9852010-02-19 01:32:20 +0000523 return llvm::Function::InternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000524
525 if (D->hasAttr<DLLExportAttr>())
John McCalld46f9852010-02-19 01:32:20 +0000526 return llvm::Function::DLLExportLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000527
528 if (D->hasAttr<WeakAttr>())
John McCalld46f9852010-02-19 01:32:20 +0000529 return llvm::Function::WeakAnyLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000530
531 // In C99 mode, 'inline' functions are guaranteed to have a strong
532 // definition somewhere else, so we can use available_externally linkage.
533 if (Linkage == GVA_C99Inline)
Fariborz Jahanianfd0f89d2011-02-04 00:08:13 +0000534 return llvm::Function::AvailableExternallyLinkage;
John McCall5584d912011-09-19 18:05:26 +0000535
536 // Note that Apple's kernel linker doesn't support symbol
537 // coalescing, so we need to avoid linkonce and weak linkages there.
538 // Normally, this means we just map to internal, but for explicit
539 // instantiations we'll map to external.
540
Chris Lattnerf81530652010-06-30 16:58:07 +0000541 // In C++, the compiler has to emit a definition in every translation unit
542 // that references the function. We should use linkonce_odr because
543 // a) if all references in this translation unit are optimized away, we
544 // don't need to codegen it. b) if the function persists, it needs to be
545 // merged with other definitions. c) C++ has the ODR, so we know the
546 // definition is dependable.
547 if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
David Blaikie4e4d0842012-03-11 07:00:24 +0000548 return !Context.getLangOpts().AppleKext
Fariborz Jahanian142f9e92011-02-04 00:01:24 +0000549 ? llvm::Function::LinkOnceODRLinkage
550 : llvm::Function::InternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000551
552 // An explicit instantiation of a template has weak linkage, since
553 // explicit instantiations can occur in multiple translation units
554 // and must all be equivalent. However, we are not allowed to
555 // throw away these explicit instantiations.
556 if (Linkage == GVA_ExplicitTemplateInstantiation)
David Blaikie4e4d0842012-03-11 07:00:24 +0000557 return !Context.getLangOpts().AppleKext
Fariborz Jahanian142f9e92011-02-04 00:01:24 +0000558 ? llvm::Function::WeakODRLinkage
John McCall5584d912011-09-19 18:05:26 +0000559 : llvm::Function::ExternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000560
561 // Otherwise, we have strong external linkage.
562 assert(Linkage == GVA_StrongExternal);
563 return llvm::Function::ExternalLinkage;
John McCalld46f9852010-02-19 01:32:20 +0000564}
Nuno Lopesd4cbda62008-06-08 15:45:52 +0000565
John McCalld46f9852010-02-19 01:32:20 +0000566
567/// SetFunctionDefinitionAttributes - Set attributes for a global.
568///
569/// FIXME: This is currently only done for aliases and functions, but not for
570/// variables (these details are set in EmitGlobalVarDefinition for variables).
571void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
572 llvm::GlobalValue *GV) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000573 SetCommonAttributes(D, GV);
Nuno Lopesd4cbda62008-06-08 15:45:52 +0000574}
575
Daniel Dunbar7dbd8192009-04-14 07:08:30 +0000576void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
Mike Stump1eb44332009-09-09 15:08:12 +0000577 const CGFunctionInfo &Info,
Daniel Dunbar7dbd8192009-04-14 07:08:30 +0000578 llvm::Function *F) {
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000579 unsigned CallingConv;
Devang Patel761d7f72008-09-25 21:02:23 +0000580 AttributeListType AttributeList;
Bill Wendling94236e72013-02-22 00:13:35 +0000581 ConstructAttributeList(Info, D, AttributeList, CallingConv, false);
Bill Wendling785b7782012-12-07 23:17:26 +0000582 F->setAttributes(llvm::AttributeSet::get(getLLVMContext(), AttributeList));
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000583 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000584}
585
John McCalld1e40d52011-10-02 01:16:38 +0000586/// Determines whether the language options require us to model
587/// unwind exceptions. We treat -fexceptions as mandating this
588/// except under the fragile ObjC ABI with only ObjC exceptions
589/// enabled. This means, for example, that C with -fexceptions
590/// enables this.
David Blaikie4e4d0842012-03-11 07:00:24 +0000591static bool hasUnwindExceptions(const LangOptions &LangOpts) {
John McCalld1e40d52011-10-02 01:16:38 +0000592 // If exceptions are completely disabled, obviously this is false.
David Blaikie4e4d0842012-03-11 07:00:24 +0000593 if (!LangOpts.Exceptions) return false;
John McCalld1e40d52011-10-02 01:16:38 +0000594
595 // If C++ exceptions are enabled, this is true.
David Blaikie4e4d0842012-03-11 07:00:24 +0000596 if (LangOpts.CXXExceptions) return true;
John McCalld1e40d52011-10-02 01:16:38 +0000597
598 // If ObjC exceptions are enabled, this depends on the ABI.
David Blaikie4e4d0842012-03-11 07:00:24 +0000599 if (LangOpts.ObjCExceptions) {
David Chisnall11d3f4c2012-07-03 20:49:52 +0000600 return LangOpts.ObjCRuntime.hasUnwindExceptions();
John McCalld1e40d52011-10-02 01:16:38 +0000601 }
602
603 return true;
604}
605
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000606void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
607 llvm::Function *F) {
Benjamin Kramer06a9d042013-05-11 12:45:37 +0000608 llvm::AttrBuilder B;
609
Rafael Espindolaabca5a12011-05-25 03:44:55 +0000610 if (CodeGenOpts.UnwindTables)
Benjamin Kramer06a9d042013-05-11 12:45:37 +0000611 B.addAttribute(llvm::Attribute::UWTable);
Rafael Espindolaabca5a12011-05-25 03:44:55 +0000612
David Blaikie4e4d0842012-03-11 07:00:24 +0000613 if (!hasUnwindExceptions(LangOpts))
Benjamin Kramer06a9d042013-05-11 12:45:37 +0000614 B.addAttribute(llvm::Attribute::NoUnwind);
Daniel Dunbaraf668b02008-10-28 00:17:57 +0000615
Eli Friedman2873aee2011-08-22 23:55:33 +0000616 if (D->hasAttr<NakedAttr>()) {
617 // Naked implies noinline: we should not be inlining such functions.
Benjamin Kramer06a9d042013-05-11 12:45:37 +0000618 B.addAttribute(llvm::Attribute::Naked);
619 B.addAttribute(llvm::Attribute::NoInline);
620 } else if (D->hasAttr<NoInlineAttr>()) {
621 B.addAttribute(llvm::Attribute::NoInline);
622 } else if ((D->hasAttr<AlwaysInlineAttr>() ||
623 D->hasAttr<ForceInlineAttr>()) &&
624 !F->getAttributes().hasAttribute(llvm::AttributeSet::FunctionIndex,
625 llvm::Attribute::NoInline)) {
626 // (noinline wins over always_inline, and we can't specify both in IR)
627 B.addAttribute(llvm::Attribute::AlwaysInline);
Eli Friedman2873aee2011-08-22 23:55:33 +0000628 }
Daniel Dunbardd0cb222010-09-29 18:20:25 +0000629
Diego Novillod27e5cb2013-05-24 20:18:15 +0000630 if (D->hasAttr<ColdAttr>()) {
Benjamin Kramer06a9d042013-05-11 12:45:37 +0000631 B.addAttribute(llvm::Attribute::OptimizeForSize);
Diego Novillod27e5cb2013-05-24 20:18:15 +0000632 B.addAttribute(llvm::Attribute::Cold);
633 }
Benjamin Krameree409a92012-05-12 21:10:52 +0000634
Quentin Colombetaee56fa2012-11-01 23:55:47 +0000635 if (D->hasAttr<MinSizeAttr>())
Benjamin Kramer06a9d042013-05-11 12:45:37 +0000636 B.addAttribute(llvm::Attribute::MinSize);
Richard Smithef4d5ce2012-09-28 22:46:07 +0000637
David Blaikie4e4d0842012-03-11 07:00:24 +0000638 if (LangOpts.getStackProtector() == LangOptions::SSPOn)
Benjamin Kramer06a9d042013-05-11 12:45:37 +0000639 B.addAttribute(llvm::Attribute::StackProtect);
David Blaikie4e4d0842012-03-11 07:00:24 +0000640 else if (LangOpts.getStackProtector() == LangOptions::SSPReq)
Benjamin Kramer06a9d042013-05-11 12:45:37 +0000641 B.addAttribute(llvm::Attribute::StackProtectReq);
Will Dietz4f45bc02013-01-18 11:30:38 +0000642
Alexey Samsonov7e73f942013-03-06 10:54:18 +0000643 // Add sanitizer attributes if function is not blacklisted.
Alexey Samsonov6a4c5dc2013-08-12 11:48:05 +0000644 if (!SanitizerBlacklist->isIn(*F)) {
Alexey Samsonov7e73f942013-03-06 10:54:18 +0000645 // When AddressSanitizer is enabled, set SanitizeAddress attribute
646 // unless __attribute__((no_sanitize_address)) is used.
647 if (SanOpts.Address && !D->hasAttr<NoSanitizeAddressAttr>())
Benjamin Kramer06a9d042013-05-11 12:45:37 +0000648 B.addAttribute(llvm::Attribute::SanitizeAddress);
Alexey Samsonov7e73f942013-03-06 10:54:18 +0000649 // Same for ThreadSanitizer and __attribute__((no_sanitize_thread))
650 if (SanOpts.Thread && !D->hasAttr<NoSanitizeThreadAttr>()) {
Benjamin Kramer06a9d042013-05-11 12:45:37 +0000651 B.addAttribute(llvm::Attribute::SanitizeThread);
Alexey Samsonov7e73f942013-03-06 10:54:18 +0000652 }
653 // Same for MemorySanitizer and __attribute__((no_sanitize_memory))
654 if (SanOpts.Memory && !D->hasAttr<NoSanitizeMemoryAttr>())
Benjamin Kramer06a9d042013-05-11 12:45:37 +0000655 B.addAttribute(llvm::Attribute::SanitizeMemory);
Alexey Samsonov7e73f942013-03-06 10:54:18 +0000656 }
Alexander Potapenko89651ea2012-02-02 11:49:28 +0000657
Benjamin Kramer06a9d042013-05-11 12:45:37 +0000658 F->addAttributes(llvm::AttributeSet::FunctionIndex,
659 llvm::AttributeSet::get(
660 F->getContext(), llvm::AttributeSet::FunctionIndex, B));
661
662 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
663 F->setUnnamedAddr(true);
664 else if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D))
665 if (MD->isVirtual())
666 F->setUnnamedAddr(true);
667
Sean Huntcf807c42010-08-18 23:23:40 +0000668 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
669 if (alignment)
670 F->setAlignment(alignment);
671
Mike Stumpfb51ddf2009-10-05 22:49:20 +0000672 // C++ ABI requires 2-byte alignment for member functions.
Mike Stumpbd6dbd12009-10-05 23:08:21 +0000673 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
674 F->setAlignment(2);
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000675}
676
Mike Stump1eb44332009-09-09 15:08:12 +0000677void CodeGenModule::SetCommonAttributes(const Decl *D,
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000678 llvm::GlobalValue *GV) {
Anders Carlsson934176f2011-01-29 19:41:00 +0000679 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
680 setGlobalVisibility(GV, ND);
John McCall1fb0caa2010-10-22 21:05:15 +0000681 else
682 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000683
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000684 if (D->hasAttr<UsedAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000685 AddUsedGlobal(GV);
686
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000687 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000688 GV->setSection(SA->getName());
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000689
Rafael Espindola9a2f5d72013-03-19 15:03:47 +0000690 // Alias cannot have attributes. Filter them here.
691 if (!isa<llvm::GlobalAlias>(GV))
692 getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000693}
694
Daniel Dunbar0e4f40e2009-04-17 00:48:04 +0000695void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
696 llvm::Function *F,
697 const CGFunctionInfo &FI) {
698 SetLLVMFunctionAttributes(D, FI, F);
699 SetLLVMFunctionAttributesForDefinition(D, F);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000700
701 F->setLinkage(llvm::Function::InternalLinkage);
702
Daniel Dunbar0e4f40e2009-04-17 00:48:04 +0000703 SetCommonAttributes(D, F);
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000704}
705
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000706void CodeGenModule::SetFunctionAttributes(GlobalDecl GD,
Eli Friedmanc6c14d12009-05-26 01:22:57 +0000707 llvm::Function *F,
708 bool IsIncompleteFunction) {
Peter Collingbourne0ac2cf42011-04-06 12:29:04 +0000709 if (unsigned IID = F->getIntrinsicID()) {
710 // If this is an intrinsic function, set the function's attributes
711 // to the intrinsic's attributes.
Bill Wendling50e6b182012-10-15 04:47:45 +0000712 F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(),
713 (llvm::Intrinsic::ID)IID));
Peter Collingbourne0ac2cf42011-04-06 12:29:04 +0000714 return;
715 }
716
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000717 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
718
Eli Friedmanc6c14d12009-05-26 01:22:57 +0000719 if (!IsIncompleteFunction)
John McCallde5d3c72012-02-17 03:33:10 +0000720 SetLLVMFunctionAttributes(FD, getTypes().arrangeGlobalDeclaration(GD), F);
Mike Stump1eb44332009-09-09 15:08:12 +0000721
Stephen Lin3b50e8d2013-06-30 20:40:16 +0000722 if (getCXXABI().HasThisReturn(GD)) {
723 assert(!F->arg_empty() &&
724 F->arg_begin()->getType()
725 ->canLosslesslyBitCastTo(F->getReturnType()) &&
726 "unexpected this return");
727 F->addAttribute(1, llvm::Attribute::Returned);
728 }
729
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000730 // Only a few attributes are set on declarations; these may later be
731 // overridden by a definition.
Mike Stump1eb44332009-09-09 15:08:12 +0000732
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000733 if (FD->hasAttr<DLLImportAttr>()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000734 F->setLinkage(llvm::Function::DLLImportLinkage);
Mike Stump1eb44332009-09-09 15:08:12 +0000735 } else if (FD->hasAttr<WeakAttr>() ||
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000736 FD->isWeakImported()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000737 // "extern_weak" is overloaded in LLVM; we probably should have
Mike Stump1eb44332009-09-09 15:08:12 +0000738 // separate linkage types for this.
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000739 F->setLinkage(llvm::Function::ExternalWeakLinkage);
740 } else {
Mike Stump1eb44332009-09-09 15:08:12 +0000741 F->setLinkage(llvm::Function::ExternalLinkage);
John McCallaf146032010-10-30 11:50:40 +0000742
Rafael Espindola2beda122013-02-27 02:15:29 +0000743 LinkageInfo LV = FD->getLinkageAndVisibility();
Rafael Espindolaf127eb82013-02-27 02:56:45 +0000744 if (LV.getLinkage() == ExternalLinkage && LV.isVisibilityExplicit()) {
745 F->setVisibility(GetLLVMVisibility(LV.getVisibility()));
John McCallaf146032010-10-30 11:50:40 +0000746 }
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000747 }
748
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000749 if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000750 F->setSection(SA->getName());
Richard Smithddcff1b2013-07-21 23:12:18 +0000751
752 // A replaceable global allocation function does not act like a builtin by
753 // default, only if it is invoked by a new-expression or delete-expression.
754 if (FD->isReplaceableGlobalAllocationFunction())
755 F->addAttribute(llvm::AttributeSet::FunctionIndex,
756 llvm::Attribute::NoBuiltin);
Daniel Dunbar219df662008-09-08 23:44:31 +0000757}
758
Daniel Dunbar02698712009-02-13 20:29:50 +0000759void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
Mike Stump1eb44332009-09-09 15:08:12 +0000760 assert(!GV->isDeclaration() &&
Daniel Dunbar02698712009-02-13 20:29:50 +0000761 "Only globals with definition can force usage.");
Chris Lattner35f38a22009-03-31 22:37:52 +0000762 LLVMUsed.push_back(GV);
Daniel Dunbar02698712009-02-13 20:29:50 +0000763}
764
765void CodeGenModule::EmitLLVMUsed() {
766 // Don't create llvm.used if there is no need.
Chris Lattnerad64e022009-07-17 23:57:13 +0000767 if (LLVMUsed.empty())
Daniel Dunbar02698712009-02-13 20:29:50 +0000768 return;
769
Chris Lattner35f38a22009-03-31 22:37:52 +0000770 // Convert LLVMUsed to what ConstantArray needs.
Chris Lattner0b239712012-02-06 22:16:34 +0000771 SmallVector<llvm::Constant*, 8> UsedArray;
Chris Lattner35f38a22009-03-31 22:37:52 +0000772 UsedArray.resize(LLVMUsed.size());
773 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
Mike Stump1eb44332009-09-09 15:08:12 +0000774 UsedArray[i] =
775 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
Chris Lattner0b239712012-02-06 22:16:34 +0000776 Int8PtrTy);
Chris Lattner35f38a22009-03-31 22:37:52 +0000777 }
Mike Stump1eb44332009-09-09 15:08:12 +0000778
Fariborz Jahanianc38e9af2009-06-23 21:47:46 +0000779 if (UsedArray.empty())
780 return;
Chris Lattner0b239712012-02-06 22:16:34 +0000781 llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size());
Mike Stump1eb44332009-09-09 15:08:12 +0000782
783 llvm::GlobalVariable *GV =
784 new llvm::GlobalVariable(getModule(), ATy, false,
Daniel Dunbar02698712009-02-13 20:29:50 +0000785 llvm::GlobalValue::AppendingLinkage,
Owen Anderson7db6d832009-07-28 18:33:04 +0000786 llvm::ConstantArray::get(ATy, UsedArray),
Owen Anderson1c431b32009-07-08 19:05:04 +0000787 "llvm.used");
Daniel Dunbar02698712009-02-13 20:29:50 +0000788
789 GV->setSection("llvm.metadata");
790}
791
Reid Kleckner3190ca92013-05-08 13:44:39 +0000792void CodeGenModule::AppendLinkerOptions(StringRef Opts) {
793 llvm::Value *MDOpts = llvm::MDString::get(getLLVMContext(), Opts);
794 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
795}
796
Aaron Ballmana7ff62f2013-06-04 02:07:14 +0000797void CodeGenModule::AddDetectMismatch(StringRef Name, StringRef Value) {
798 llvm::SmallString<32> Opt;
799 getTargetCodeGenInfo().getDetectMismatchOption(Name, Value, Opt);
800 llvm::Value *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
801 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
802}
803
Reid Kleckner3190ca92013-05-08 13:44:39 +0000804void CodeGenModule::AddDependentLib(StringRef Lib) {
805 llvm::SmallString<24> Opt;
806 getTargetCodeGenInfo().getDependentLibraryOption(Lib, Opt);
807 llvm::Value *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
808 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
809}
810
Douglas Gregor858afb32013-01-14 20:53:57 +0000811/// \brief Add link options implied by the given module, including modules
812/// it depends on, using a postorder walk.
Reid Kleckner3190ca92013-05-08 13:44:39 +0000813static void addLinkOptionsPostorder(CodeGenModule &CGM,
Douglas Gregor858afb32013-01-14 20:53:57 +0000814 Module *Mod,
Daniel Dunbarf9d03c12013-01-17 01:35:06 +0000815 SmallVectorImpl<llvm::Value *> &Metadata,
Douglas Gregor858afb32013-01-14 20:53:57 +0000816 llvm::SmallPtrSet<Module *, 16> &Visited) {
817 // Import this module's parent.
818 if (Mod->Parent && Visited.insert(Mod->Parent)) {
Reid Kleckner3190ca92013-05-08 13:44:39 +0000819 addLinkOptionsPostorder(CGM, Mod->Parent, Metadata, Visited);
Douglas Gregor858afb32013-01-14 20:53:57 +0000820 }
821
822 // Import this module's dependencies.
823 for (unsigned I = Mod->Imports.size(); I > 0; --I) {
824 if (Visited.insert(Mod->Imports[I-1]))
Reid Kleckner3190ca92013-05-08 13:44:39 +0000825 addLinkOptionsPostorder(CGM, Mod->Imports[I-1], Metadata, Visited);
Douglas Gregor858afb32013-01-14 20:53:57 +0000826 }
827
828 // Add linker options to link against the libraries/frameworks
829 // described by this module.
Reid Kleckner3190ca92013-05-08 13:44:39 +0000830 llvm::LLVMContext &Context = CGM.getLLVMContext();
Douglas Gregor858afb32013-01-14 20:53:57 +0000831 for (unsigned I = Mod->LinkLibraries.size(); I > 0; --I) {
Reid Kleckner3190ca92013-05-08 13:44:39 +0000832 // Link against a framework. Frameworks are currently Darwin only, so we
833 // don't to ask TargetCodeGenInfo for the spelling of the linker option.
Douglas Gregor858afb32013-01-14 20:53:57 +0000834 if (Mod->LinkLibraries[I-1].IsFramework) {
835 llvm::Value *Args[2] = {
836 llvm::MDString::get(Context, "-framework"),
837 llvm::MDString::get(Context, Mod->LinkLibraries[I-1].Library)
838 };
839
840 Metadata.push_back(llvm::MDNode::get(Context, Args));
841 continue;
842 }
843
844 // Link against a library.
Reid Kleckner3190ca92013-05-08 13:44:39 +0000845 llvm::SmallString<24> Opt;
846 CGM.getTargetCodeGenInfo().getDependentLibraryOption(
847 Mod->LinkLibraries[I-1].Library, Opt);
848 llvm::Value *OptString = llvm::MDString::get(Context, Opt);
Douglas Gregor858afb32013-01-14 20:53:57 +0000849 Metadata.push_back(llvm::MDNode::get(Context, OptString));
850 }
851}
852
853void CodeGenModule::EmitModuleLinkOptions() {
854 // Collect the set of all of the modules we want to visit to emit link
855 // options, which is essentially the imported modules and all of their
856 // non-explicit child modules.
857 llvm::SetVector<clang::Module *> LinkModules;
858 llvm::SmallPtrSet<clang::Module *, 16> Visited;
859 SmallVector<clang::Module *, 16> Stack;
860
861 // Seed the stack with imported modules.
862 for (llvm::SetVector<clang::Module *>::iterator M = ImportedModules.begin(),
863 MEnd = ImportedModules.end();
864 M != MEnd; ++M) {
865 if (Visited.insert(*M))
866 Stack.push_back(*M);
867 }
868
869 // Find all of the modules to import, making a little effort to prune
870 // non-leaf modules.
871 while (!Stack.empty()) {
872 clang::Module *Mod = Stack.back();
873 Stack.pop_back();
874
875 bool AnyChildren = false;
876
877 // Visit the submodules of this module.
878 for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(),
879 SubEnd = Mod->submodule_end();
880 Sub != SubEnd; ++Sub) {
881 // Skip explicit children; they need to be explicitly imported to be
882 // linked against.
883 if ((*Sub)->IsExplicit)
884 continue;
885
886 if (Visited.insert(*Sub)) {
887 Stack.push_back(*Sub);
888 AnyChildren = true;
889 }
890 }
891
892 // We didn't find any children, so add this module to the list of
893 // modules to link against.
894 if (!AnyChildren) {
895 LinkModules.insert(Mod);
896 }
897 }
898
899 // Add link options for all of the imported modules in reverse topological
Reid Kleckner3190ca92013-05-08 13:44:39 +0000900 // order. We don't do anything to try to order import link flags with respect
901 // to linker options inserted by things like #pragma comment().
Daniel Dunbarf9d03c12013-01-17 01:35:06 +0000902 SmallVector<llvm::Value *, 16> MetadataArgs;
Douglas Gregor858afb32013-01-14 20:53:57 +0000903 Visited.clear();
904 for (llvm::SetVector<clang::Module *>::iterator M = LinkModules.begin(),
905 MEnd = LinkModules.end();
906 M != MEnd; ++M) {
907 if (Visited.insert(*M))
Reid Kleckner3190ca92013-05-08 13:44:39 +0000908 addLinkOptionsPostorder(*this, *M, MetadataArgs, Visited);
Douglas Gregor858afb32013-01-14 20:53:57 +0000909 }
Daniel Dunbarf9d03c12013-01-17 01:35:06 +0000910 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
Reid Kleckner3190ca92013-05-08 13:44:39 +0000911 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
Douglas Gregor858afb32013-01-14 20:53:57 +0000912
Daniel Dunbarf9d03c12013-01-17 01:35:06 +0000913 // Add the linker options metadata flag.
914 getModule().addModuleFlag(llvm::Module::AppendUnique, "Linker Options",
Reid Kleckner3190ca92013-05-08 13:44:39 +0000915 llvm::MDNode::get(getLLVMContext(),
916 LinkerOptionsMetadata));
Douglas Gregor858afb32013-01-14 20:53:57 +0000917}
918
Daniel Dunbar02698712009-02-13 20:29:50 +0000919void CodeGenModule::EmitDeferred() {
Chris Lattner67b00522009-03-21 09:44:56 +0000920 // Emit code for any potentially referenced deferred decls. Since a
921 // previously unused static decl may become used during the generation of code
Nick Lewyckydce67a72011-07-18 05:26:13 +0000922 // for a static function, iterate until no changes are made.
Rafael Espindolabbf58bb2010-03-10 02:19:29 +0000923
John McCalld5617ee2013-01-25 22:31:03 +0000924 while (true) {
Anders Carlsson046c2942010-04-17 20:15:18 +0000925 if (!DeferredVTables.empty()) {
John McCalld5617ee2013-01-25 22:31:03 +0000926 EmitDeferredVTables();
927
928 // Emitting a v-table doesn't directly cause more v-tables to
929 // become deferred, although it can cause functions to be
930 // emitted that then need those v-tables.
931 assert(DeferredVTables.empty());
Rafael Espindolabbf58bb2010-03-10 02:19:29 +0000932 }
933
John McCalld5617ee2013-01-25 22:31:03 +0000934 // Stop if we're out of both deferred v-tables and deferred declarations.
935 if (DeferredDeclsToEmit.empty()) break;
936
Anders Carlsson2a131fb2009-05-05 04:44:02 +0000937 GlobalDecl D = DeferredDeclsToEmit.back();
Chris Lattner67b00522009-03-21 09:44:56 +0000938 DeferredDeclsToEmit.pop_back();
939
John McCallc76702c2010-05-27 01:45:30 +0000940 // Check to see if we've already emitted this. This is necessary
941 // for a couple of reasons: first, decls can end up in the
942 // deferred-decls queue multiple times, and second, decls can end
943 // up with definitions in unusual ways (e.g. by an extern inline
944 // function acquiring a strong function redefinition). Just
945 // ignore these cases.
946 //
947 // TODO: That said, looking this up multiple times is very wasteful.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000948 StringRef Name = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +0000949 llvm::GlobalValue *CGRef = GetGlobalValue(Name);
Chris Lattner67b00522009-03-21 09:44:56 +0000950 assert(CGRef && "Deferred decl wasn't referenced?");
Mike Stump1eb44332009-09-09 15:08:12 +0000951
Chris Lattner67b00522009-03-21 09:44:56 +0000952 if (!CGRef->isDeclaration())
953 continue;
Mike Stump1eb44332009-09-09 15:08:12 +0000954
John McCallc76702c2010-05-27 01:45:30 +0000955 // GlobalAlias::isDeclaration() defers to the aliasee, but for our
956 // purposes an alias counts as a definition.
957 if (isa<llvm::GlobalAlias>(CGRef))
958 continue;
959
Chris Lattner67b00522009-03-21 09:44:56 +0000960 // Otherwise, emit the definition and move on to the next one.
961 EmitGlobalDefinition(D);
962 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000963}
964
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000965void CodeGenModule::EmitGlobalAnnotations() {
966 if (Annotations.empty())
967 return;
968
969 // Create a new global variable for the ConstantStruct in the Module.
970 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
971 Annotations[0]->getType(), Annotations.size()), Annotations);
972 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(),
973 Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array,
974 "llvm.global.annotations");
975 gv->setSection(AnnotationSection);
976}
977
Dmitri Gribenkocfa88f82013-01-12 19:30:44 +0000978llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000979 llvm::StringMap<llvm::Constant*>::iterator i = AnnotationStrings.find(Str);
980 if (i != AnnotationStrings.end())
981 return i->second;
982
983 // Not found yet, create a new global.
Chris Lattner94010692012-02-05 02:30:40 +0000984 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000985 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(),
986 true, llvm::GlobalValue::PrivateLinkage, s, ".str");
987 gv->setSection(AnnotationSection);
988 gv->setUnnamedAddr(true);
989 AnnotationStrings[Str] = gv;
990 return gv;
991}
992
993llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) {
994 SourceManager &SM = getContext().getSourceManager();
995 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
996 if (PLoc.isValid())
997 return EmitAnnotationString(PLoc.getFilename());
998 return EmitAnnotationString(SM.getBufferName(Loc));
999}
1000
1001llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
1002 SourceManager &SM = getContext().getSourceManager();
1003 PresumedLoc PLoc = SM.getPresumedLoc(L);
1004 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
1005 SM.getExpansionLineNumber(L);
1006 return llvm::ConstantInt::get(Int32Ty, LineNo);
1007}
1008
Mike Stump1eb44332009-09-09 15:08:12 +00001009llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
Nate Begeman8bd4afe2008-04-19 04:17:09 +00001010 const AnnotateAttr *AA,
Julien Lerouge77f68bb2011-09-09 22:41:49 +00001011 SourceLocation L) {
1012 // Get the globals for file name, annotation, and the line number.
1013 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
1014 *UnitGV = EmitAnnotationUnit(L),
1015 *LineNoCst = EmitAnnotationLineNo(L);
Nate Begeman8bd4afe2008-04-19 04:17:09 +00001016
Daniel Dunbar57d5cee2009-04-14 22:41:13 +00001017 // Create the ConstantStruct for the global annotation.
Nate Begeman8bd4afe2008-04-19 04:17:09 +00001018 llvm::Constant *Fields[4] = {
Julien Lerouge77f68bb2011-09-09 22:41:49 +00001019 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
1020 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
1021 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
1022 LineNoCst
Nate Begeman8bd4afe2008-04-19 04:17:09 +00001023 };
Chris Lattnerc5cbb902011-06-20 04:01:35 +00001024 return llvm::ConstantStruct::getAnon(Fields);
Nate Begeman8bd4afe2008-04-19 04:17:09 +00001025}
1026
Julien Lerouge77f68bb2011-09-09 22:41:49 +00001027void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
1028 llvm::GlobalValue *GV) {
1029 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
1030 // Get the struct elements for these annotations.
1031 for (specific_attr_iterator<AnnotateAttr>
1032 ai = D->specific_attr_begin<AnnotateAttr>(),
1033 ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai)
1034 Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation()));
1035}
1036
Argyrios Kyrtzidisa6d6af32010-07-27 22:37:14 +00001037bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
Argyrios Kyrtzidis90e99a82010-07-29 18:15:58 +00001038 // Never defer when EmitAllDecls is specified.
David Blaikie4e4d0842012-03-11 07:00:24 +00001039 if (LangOpts.EmitAllDecls)
Daniel Dunbar73241df2009-02-13 21:18:01 +00001040 return false;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001041
Argyrios Kyrtzidis4ac7c0b2010-07-29 20:08:05 +00001042 return !getContext().DeclMustBeEmitted(Global);
Daniel Dunbar73241df2009-02-13 21:18:01 +00001043}
1044
Nico Weberc5f80462012-10-11 10:13:44 +00001045llvm::Constant *CodeGenModule::GetAddrOfUuidDescriptor(
1046 const CXXUuidofExpr* E) {
1047 // Sema has verified that IIDSource has a __declspec(uuid()), and that its
1048 // well-formed.
David Majnemerc80eb462013-08-13 06:32:20 +00001049 StringRef Uuid = E->getUuidAsStringRef(Context);
David Majnemerc8fe0112013-08-09 08:35:59 +00001050 std::string Name = "_GUID_" + Uuid.lower();
1051 std::replace(Name.begin(), Name.end(), '-', '_');
Nico Weberc5f80462012-10-11 10:13:44 +00001052
1053 // Look for an existing global.
1054 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
1055 return GV;
1056
1057 llvm::Constant *Init = EmitUuidofInitializer(Uuid, E->getType());
1058 assert(Init && "failed to initialize as constant");
1059
1060 // GUIDs are assumed to be 16 bytes, spread over 4-2-2-8 bytes. However, the
1061 // first field is declared as "long", which for many targets is 8 bytes.
1062 // Those architectures are not supported. (With the MS abi, long is always 4
1063 // bytes.)
1064 llvm::Type *GuidType = getTypes().ConvertType(E->getType());
1065 if (Init->getType() != GuidType) {
1066 DiagnosticsEngine &Diags = getDiags();
1067 unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
1068 "__uuidof codegen is not supported on this architecture");
1069 Diags.Report(E->getExprLoc(), DiagID) << E->getSourceRange();
1070 Init = llvm::UndefValue::get(GuidType);
1071 }
1072
1073 llvm::GlobalVariable *GV = new llvm::GlobalVariable(getModule(), GuidType,
David Majnemerc8fe0112013-08-09 08:35:59 +00001074 /*isConstant=*/true, llvm::GlobalValue::ExternalLinkage, Init, Name);
Nico Weberc5f80462012-10-11 10:13:44 +00001075 GV->setUnnamedAddr(true);
1076 return GV;
1077}
1078
Rafael Espindola6a836702010-03-04 18:17:24 +00001079llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
1080 const AliasAttr *AA = VD->getAttr<AliasAttr>();
1081 assert(AA && "No alias?");
1082
Chris Lattner2acc6e32011-07-18 04:24:23 +00001083 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
Rafael Espindola6a836702010-03-04 18:17:24 +00001084
Rafael Espindola6a836702010-03-04 18:17:24 +00001085 // See if there is already something with the target's name in the module.
John McCallf746aa62010-03-19 23:29:14 +00001086 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
Joerg Sonnenberger4695f912012-10-16 17:45:27 +00001087 if (Entry) {
1088 unsigned AS = getContext().getTargetAddressSpace(VD->getType());
1089 return llvm::ConstantExpr::getBitCast(Entry, DeclTy->getPointerTo(AS));
1090 }
Rafael Espindola6a836702010-03-04 18:17:24 +00001091
1092 llvm::Constant *Aliasee;
1093 if (isa<llvm::FunctionType>(DeclTy))
Alex Rosenbergc857ce82012-10-05 23:12:53 +00001094 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
1095 GlobalDecl(cast<FunctionDecl>(VD)),
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001096 /*ForVTable=*/false);
Rafael Espindola6a836702010-03-04 18:17:24 +00001097 else
John McCallf746aa62010-03-19 23:29:14 +00001098 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Rafael Espindola6a836702010-03-04 18:17:24 +00001099 llvm::PointerType::getUnqual(DeclTy), 0);
Joerg Sonnenberger4695f912012-10-16 17:45:27 +00001100
1101 llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee);
1102 F->setLinkage(llvm::Function::ExternalWeakLinkage);
1103 WeakRefReferences.insert(F);
Rafael Espindola6a836702010-03-04 18:17:24 +00001104
1105 return Aliasee;
1106}
1107
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001108void CodeGenModule::EmitGlobal(GlobalDecl GD) {
Anders Carlsson4a6835e2009-09-10 23:38:47 +00001109 const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00001110
Rafael Espindola6a836702010-03-04 18:17:24 +00001111 // Weak references don't produce any output by themselves.
1112 if (Global->hasAttr<WeakRefAttr>())
1113 return;
1114
Chris Lattnerbd532712009-03-22 21:47:11 +00001115 // If this is an alias definition (which otherwise looks like a declaration)
1116 // emit it now.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001117 if (Global->hasAttr<AliasAttr>())
John McCallf746aa62010-03-19 23:29:14 +00001118 return EmitAliasDefinition(GD);
Daniel Dunbar219df662008-09-08 23:44:31 +00001119
Peter Collingbourned51e43a2011-10-06 18:29:46 +00001120 // If this is CUDA, be selective about which declarations we emit.
David Blaikie4e4d0842012-03-11 07:00:24 +00001121 if (LangOpts.CUDA) {
Peter Collingbourned51e43a2011-10-06 18:29:46 +00001122 if (CodeGenOpts.CUDAIsDevice) {
1123 if (!Global->hasAttr<CUDADeviceAttr>() &&
1124 !Global->hasAttr<CUDAGlobalAttr>() &&
1125 !Global->hasAttr<CUDAConstantAttr>() &&
1126 !Global->hasAttr<CUDASharedAttr>())
1127 return;
1128 } else {
1129 if (!Global->hasAttr<CUDAHostAttr>() && (
1130 Global->hasAttr<CUDADeviceAttr>() ||
1131 Global->hasAttr<CUDAConstantAttr>() ||
1132 Global->hasAttr<CUDASharedAttr>()))
1133 return;
1134 }
1135 }
1136
Chris Lattner67b00522009-03-21 09:44:56 +00001137 // Ignore declarations, they will be emitted on their first use.
Daniel Dunbar5e1e1f92009-03-19 08:27:24 +00001138 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
Daniel Dunbar73241df2009-02-13 21:18:01 +00001139 // Forward declarations are emitted lazily on first use.
Nick Lewyckydce67a72011-07-18 05:26:13 +00001140 if (!FD->doesThisDeclarationHaveABody()) {
1141 if (!FD->doesDeclarationForceExternallyVisibleDefinition())
1142 return;
1143
1144 const FunctionDecl *InlineDefinition = 0;
1145 FD->getBody(InlineDefinition);
1146
Chris Lattner5f9e2722011-07-23 10:55:15 +00001147 StringRef MangledName = getMangledName(GD);
Benjamin Kramer7e423922012-03-24 18:22:12 +00001148 DeferredDecls.erase(MangledName);
Nick Lewyckydce67a72011-07-18 05:26:13 +00001149 EmitGlobalDefinition(InlineDefinition);
Daniel Dunbar73241df2009-02-13 21:18:01 +00001150 return;
Nick Lewyckydce67a72011-07-18 05:26:13 +00001151 }
Daniel Dunbar02698712009-02-13 20:29:50 +00001152 } else {
1153 const VarDecl *VD = cast<VarDecl>(Global);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001154 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
1155
Douglas Gregora9a55c02010-02-06 05:15:45 +00001156 if (VD->isThisDeclarationADefinition() != VarDecl::Definition)
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +00001157 return;
Nate Begeman4c13b7a2008-04-20 06:29:50 +00001158 }
1159
Chris Lattner67b00522009-03-21 09:44:56 +00001160 // Defer code generation when possible if this is a static definition, inline
1161 // function etc. These we only want to emit if they are used.
Chris Lattner4357a822010-04-13 17:39:09 +00001162 if (!MayDeferGeneration(Global)) {
1163 // Emit the definition if it can't be deferred.
1164 EmitGlobalDefinition(GD);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001165 return;
1166 }
John McCallbf40cb52010-07-15 23:40:35 +00001167
1168 // If we're deferring emission of a C++ variable with an
1169 // initializer, remember the order in which it appeared in the file.
David Blaikie4e4d0842012-03-11 07:00:24 +00001170 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
John McCallbf40cb52010-07-15 23:40:35 +00001171 cast<VarDecl>(Global)->hasInit()) {
1172 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
1173 CXXGlobalInits.push_back(0);
1174 }
Chris Lattner4357a822010-04-13 17:39:09 +00001175
1176 // If the value has already been used, add it directly to the
1177 // DeferredDeclsToEmit list.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001178 StringRef MangledName = getMangledName(GD);
Chris Lattner4357a822010-04-13 17:39:09 +00001179 if (GetGlobalValue(MangledName))
1180 DeferredDeclsToEmit.push_back(GD);
1181 else {
1182 // Otherwise, remember that we saw a deferred decl with this name. The
1183 // first use of the mangled name will cause it to move into
1184 // DeferredDeclsToEmit.
1185 DeferredDecls[MangledName] = GD;
1186 }
Nate Begeman4c13b7a2008-04-20 06:29:50 +00001187}
1188
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001189namespace {
1190 struct FunctionIsDirectlyRecursive :
1191 public RecursiveASTVisitor<FunctionIsDirectlyRecursive> {
1192 const StringRef Name;
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001193 const Builtin::Context &BI;
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001194 bool Result;
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001195 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C) :
1196 Name(N), BI(C), Result(false) {
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001197 }
1198 typedef RecursiveASTVisitor<FunctionIsDirectlyRecursive> Base;
1199
1200 bool TraverseCallExpr(CallExpr *E) {
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001201 const FunctionDecl *FD = E->getDirectCallee();
1202 if (!FD)
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001203 return true;
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001204 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1205 if (Attr && Name == Attr->getLabel()) {
1206 Result = true;
1207 return false;
1208 }
1209 unsigned BuiltinID = FD->getBuiltinID();
1210 if (!BuiltinID)
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001211 return true;
Nick Lewyckyf6b56372012-01-18 03:41:19 +00001212 StringRef BuiltinName = BI.GetName(BuiltinID);
1213 if (BuiltinName.startswith("__builtin_") &&
1214 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001215 Result = true;
1216 return false;
1217 }
1218 return true;
1219 }
1220 };
1221}
1222
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001223// isTriviallyRecursive - Check if this function calls another
1224// decl that, because of the asm attribute or the other decl being a builtin,
1225// ends up pointing to itself.
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001226bool
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001227CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
1228 StringRef Name;
1229 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
Nick Lewycky22afacc2012-01-18 01:50:13 +00001230 // asm labels are a special kind of mangling we have to support.
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001231 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
1232 if (!Attr)
1233 return false;
1234 Name = Attr->getLabel();
1235 } else {
1236 Name = FD->getName();
1237 }
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001238
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001239 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
1240 Walker.TraverseFunctionDecl(const_cast<FunctionDecl*>(FD));
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001241 return Walker.Result;
1242}
1243
1244bool
Peter Collingbourne144a31f2013-06-05 17:49:37 +00001245CodeGenModule::shouldEmitFunction(GlobalDecl GD) {
1246 if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage)
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001247 return true;
Peter Collingbourne144a31f2013-06-05 17:49:37 +00001248 const FunctionDecl *F = cast<FunctionDecl>(GD.getDecl());
Rafael Espindolacc4889f2011-10-28 20:43:56 +00001249 if (CodeGenOpts.OptimizationLevel == 0 &&
Michael J. Spenceradc6cbf2012-06-18 07:00:48 +00001250 !F->hasAttr<AlwaysInlineAttr>() && !F->hasAttr<ForceInlineAttr>())
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001251 return false;
1252 // PR9614. Avoid cases where the source code is lying to us. An available
1253 // externally function should have an equivalent function somewhere else,
1254 // but a function that calls itself is clearly not equivalent to the real
1255 // implementation.
1256 // This happens in glibc's btowc and in some configure checks.
Rafael Espindolabcf6b982011-12-19 14:41:01 +00001257 return !isTriviallyRecursive(F);
Rafael Espindolaa411d2f2011-10-26 20:41:06 +00001258}
1259
Adrian Prantl0a050f72013-05-09 23:16:27 +00001260/// If the type for the method's class was generated by
1261/// CGDebugInfo::createContextChain(), the cache contains only a
1262/// limited DIType without any declarations. Since EmitFunctionStart()
1263/// needs to find the canonical declaration for each method, we need
1264/// to construct the complete type prior to emitting the method.
1265void CodeGenModule::CompleteDIClassType(const CXXMethodDecl* D) {
1266 if (!D->isInstance())
1267 return;
1268
1269 if (CGDebugInfo *DI = getModuleDebugInfo())
1270 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo) {
1271 const PointerType *ThisPtr =
1272 cast<PointerType>(D->getThisType(getContext()));
1273 DI->getOrCreateRecordType(ThisPtr->getPointeeType(), D->getLocation());
1274 }
1275}
1276
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001277void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
Anders Carlsson4a6835e2009-09-10 23:38:47 +00001278 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +00001279
Dan Gohmancb421fa2010-04-19 16:39:44 +00001280 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
Anders Carlsson8e2efcc2009-10-27 14:32:27 +00001281 Context.getSourceManager(),
1282 "Generating code for declaration");
1283
Peter Collingbourne144a31f2013-06-05 17:49:37 +00001284 if (isa<FunctionDecl>(D)) {
Douglas Gregor44eac332010-07-13 06:02:28 +00001285 // At -O0, don't generate IR for functions with available_externally
1286 // linkage.
Peter Collingbourne144a31f2013-06-05 17:49:37 +00001287 if (!shouldEmitFunction(GD))
Douglas Gregor44eac332010-07-13 06:02:28 +00001288 return;
Anders Carlsson7270ee42010-03-23 04:31:31 +00001289
Douglas Gregor44eac332010-07-13 06:02:28 +00001290 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
Adrian Prantl0a050f72013-05-09 23:16:27 +00001291 CompleteDIClassType(Method);
Eli Friedman7dcdf5b2011-05-06 17:27:27 +00001292 // Make sure to emit the definition(s) before we emit the thunks.
1293 // This is necessary for the generation of certain thunks.
1294 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
1295 EmitCXXConstructor(CD, GD.getCtorType());
1296 else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method))
1297 EmitCXXDestructor(DD, GD.getDtorType());
1298 else
1299 EmitGlobalFunctionDefinition(GD);
1300
Douglas Gregor44eac332010-07-13 06:02:28 +00001301 if (Method->isVirtual())
1302 getVTables().EmitThunks(GD);
1303
Eli Friedman7dcdf5b2011-05-06 17:27:27 +00001304 return;
Douglas Gregor44eac332010-07-13 06:02:28 +00001305 }
Chris Lattnerb5e81562010-04-13 17:57:11 +00001306
Chris Lattnerb5e81562010-04-13 17:57:11 +00001307 return EmitGlobalFunctionDefinition(GD);
Douglas Gregor44eac332010-07-13 06:02:28 +00001308 }
Chris Lattnerb5e81562010-04-13 17:57:11 +00001309
1310 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
1311 return EmitGlobalVarDefinition(VD);
Chris Lattner4357a822010-04-13 17:39:09 +00001312
David Blaikieb219cfc2011-09-23 05:06:16 +00001313 llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001314}
1315
Chris Lattner74391b42009-03-22 21:03:39 +00001316/// GetOrCreateLLVMFunction - If the specified mangled name is not in the
1317/// module, create and return an llvm Function with the specified type. If there
1318/// is something in the module with the specified name, return it potentially
1319/// bitcasted to the right type.
1320///
1321/// If D is non-null, it specifies a decl that correspond to this. This is used
1322/// to set the attributes on the function when it is first created.
John McCallf746aa62010-03-19 23:29:14 +00001323llvm::Constant *
Chris Lattner5f9e2722011-07-23 10:55:15 +00001324CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001325 llvm::Type *Ty,
Reid Kleckner73701ea2013-07-22 13:07:10 +00001326 GlobalDecl GD, bool ForVTable,
Bill Wendlingc4c62fd2013-01-31 00:30:05 +00001327 llvm::AttributeSet ExtraAttrs) {
Reid Kleckner73701ea2013-07-22 13:07:10 +00001328 const Decl *D = GD.getDecl();
1329
Chris Lattner0558e792009-03-21 09:25:43 +00001330 // Lookup the entry, lazily creating it if necessary.
John McCallf746aa62010-03-19 23:29:14 +00001331 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner0558e792009-03-21 09:25:43 +00001332 if (Entry) {
Benjamin Kramerd48bcb22012-08-22 15:37:55 +00001333 if (WeakRefReferences.erase(Entry)) {
Reid Kleckner73701ea2013-07-22 13:07:10 +00001334 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
Rafael Espindola6a836702010-03-04 18:17:24 +00001335 if (FD && !FD->hasAttr<WeakAttr>())
Anders Carlsson7270ee42010-03-23 04:31:31 +00001336 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola6a836702010-03-04 18:17:24 +00001337 }
1338
Chris Lattner0558e792009-03-21 09:25:43 +00001339 if (Entry->getType()->getElementType() == Ty)
1340 return Entry;
Mike Stump1eb44332009-09-09 15:08:12 +00001341
Chris Lattner0558e792009-03-21 09:25:43 +00001342 // Make sure the result is of the correct type.
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001343 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
Chris Lattner0558e792009-03-21 09:25:43 +00001344 }
Mike Stump1eb44332009-09-09 15:08:12 +00001345
Reid Klecknera4130ba2013-07-22 13:51:44 +00001346 // All MSVC dtors other than the base dtor are linkonce_odr and delegate to
1347 // each other bottoming out with the base dtor. Therefore we emit non-base
1348 // dtors on usage, even if there is no dtor definition in the TU.
1349 if (D && isa<CXXDestructorDecl>(D) &&
1350 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
1351 GD.getDtorType()))
1352 DeferredDeclsToEmit.push_back(GD);
1353
Eli Friedman654ad402009-11-09 05:07:37 +00001354 // This function doesn't have a complete type (for example, the return
1355 // type is an incomplete struct). Use a fake type instead, and make
1356 // sure not to try to set attributes.
1357 bool IsIncompleteFunction = false;
John McCall784f2112010-04-28 00:00:30 +00001358
Chris Lattner2acc6e32011-07-18 04:24:23 +00001359 llvm::FunctionType *FTy;
John McCall784f2112010-04-28 00:00:30 +00001360 if (isa<llvm::FunctionType>(Ty)) {
1361 FTy = cast<llvm::FunctionType>(Ty);
1362 } else {
John McCall0774cb82011-05-15 01:53:33 +00001363 FTy = llvm::FunctionType::get(VoidTy, false);
Eli Friedman654ad402009-11-09 05:07:37 +00001364 IsIncompleteFunction = true;
1365 }
Chris Lattnerbcaedae2010-06-30 19:14:05 +00001366
John McCall784f2112010-04-28 00:00:30 +00001367 llvm::Function *F = llvm::Function::Create(FTy,
Eli Friedman654ad402009-11-09 05:07:37 +00001368 llvm::Function::ExternalLinkage,
John McCallf746aa62010-03-19 23:29:14 +00001369 MangledName, &getModule());
1370 assert(F->getName() == MangledName && "name was uniqued!");
Reid Kleckner73701ea2013-07-22 13:07:10 +00001371 if (D)
1372 SetFunctionAttributes(GD, F, IsIncompleteFunction);
Bill Wendlingc4c62fd2013-01-31 00:30:05 +00001373 if (ExtraAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex)) {
1374 llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeSet::FunctionIndex);
Bill Wendling909b6de2013-01-23 00:21:06 +00001375 F->addAttributes(llvm::AttributeSet::FunctionIndex,
1376 llvm::AttributeSet::get(VMContext,
1377 llvm::AttributeSet::FunctionIndex,
1378 B));
1379 }
Eli Friedman654ad402009-11-09 05:07:37 +00001380
Chris Lattner67b00522009-03-21 09:44:56 +00001381 // This is the first use or definition of a mangled name. If there is a
1382 // deferred decl with this name, remember that we need to emit it at the end
1383 // of the file.
John McCallf746aa62010-03-19 23:29:14 +00001384 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner67b00522009-03-21 09:44:56 +00001385 if (DDI != DeferredDecls.end()) {
1386 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1387 // list, and remove it from DeferredDecls (since we don't need it anymore).
1388 DeferredDeclsToEmit.push_back(DDI->second);
1389 DeferredDecls.erase(DDI);
John McCallbfdcdc82010-12-15 04:00:32 +00001390
1391 // Otherwise, there are cases we have to worry about where we're
1392 // using a declaration for which we must emit a definition but where
1393 // we might not find a top-level definition:
1394 // - member functions defined inline in their classes
1395 // - friend functions defined inline in some class
1396 // - special member functions with implicit definitions
1397 // If we ever change our AST traversal to walk into class methods,
1398 // this will be unnecessary.
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001399 //
1400 // We also don't emit a definition for a function if it's going to be an entry
1401 // in a vtable, unless it's already marked as used.
Reid Kleckner73701ea2013-07-22 13:07:10 +00001402 } else if (getLangOpts().CPlusPlus && D) {
John McCallbfdcdc82010-12-15 04:00:32 +00001403 // Look for a declaration that's lexically in a record.
Reid Kleckner73701ea2013-07-22 13:07:10 +00001404 const FunctionDecl *FD = cast<FunctionDecl>(D);
Eli Friedmanb135f0f2012-07-02 21:05:30 +00001405 FD = FD->getMostRecentDecl();
John McCallbfdcdc82010-12-15 04:00:32 +00001406 do {
1407 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001408 if (FD->isImplicit() && !ForVTable) {
John McCallbfdcdc82010-12-15 04:00:32 +00001409 assert(FD->isUsed() && "Sema didn't mark implicit function as used!");
Reid Kleckner73701ea2013-07-22 13:07:10 +00001410 DeferredDeclsToEmit.push_back(GD.getWithDecl(FD));
John McCallbfdcdc82010-12-15 04:00:32 +00001411 break;
Sean Hunt10620eb2011-05-06 20:44:56 +00001412 } else if (FD->doesThisDeclarationHaveABody()) {
Reid Kleckner73701ea2013-07-22 13:07:10 +00001413 DeferredDeclsToEmit.push_back(GD.getWithDecl(FD));
John McCallbfdcdc82010-12-15 04:00:32 +00001414 break;
1415 }
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +00001416 }
Douglas Gregoref96ee02012-01-14 16:38:05 +00001417 FD = FD->getPreviousDecl();
John McCallbfdcdc82010-12-15 04:00:32 +00001418 } while (FD);
Chris Lattner67b00522009-03-21 09:44:56 +00001419 }
Mike Stump1eb44332009-09-09 15:08:12 +00001420
John McCall784f2112010-04-28 00:00:30 +00001421 // Make sure the result is of the requested type.
1422 if (!IsIncompleteFunction) {
1423 assert(F->getType()->getElementType() == Ty);
1424 return F;
1425 }
1426
Chris Lattner9cbe4f02011-07-09 17:41:47 +00001427 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
John McCall784f2112010-04-28 00:00:30 +00001428 return llvm::ConstantExpr::getBitCast(F, PTy);
Chris Lattner0558e792009-03-21 09:25:43 +00001429}
1430
Chris Lattner74391b42009-03-22 21:03:39 +00001431/// GetAddrOfFunction - Return the address of the given function. If Ty is
1432/// non-null, then this function will use the specified type if it has to
1433/// create it (this occurs when we see a definition of the function).
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001434llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001435 llvm::Type *Ty,
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001436 bool ForVTable) {
Chris Lattner74391b42009-03-22 21:03:39 +00001437 // If there was no specific requested type, just convert it now.
1438 if (!Ty)
Anders Carlsson4a6835e2009-09-10 23:38:47 +00001439 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
Chris Lattnerbcaedae2010-06-30 19:14:05 +00001440
Chris Lattner5f9e2722011-07-23 10:55:15 +00001441 StringRef MangledName = getMangledName(GD);
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001442 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable);
Chris Lattner74391b42009-03-22 21:03:39 +00001443}
Eli Friedman77ba7082008-05-30 19:50:47 +00001444
Chris Lattner74391b42009-03-22 21:03:39 +00001445/// CreateRuntimeFunction - Create a new runtime function with the specified
1446/// type and name.
1447llvm::Constant *
Chris Lattner2acc6e32011-07-18 04:24:23 +00001448CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001449 StringRef Name,
Bill Wendlingc4c62fd2013-01-31 00:30:05 +00001450 llvm::AttributeSet ExtraAttrs) {
John McCallbd7370a2013-02-28 19:01:20 +00001451 llvm::Constant *C
1452 = GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
1453 ExtraAttrs);
1454 if (llvm::Function *F = dyn_cast<llvm::Function>(C))
1455 if (F->empty())
1456 F->setCallingConv(getRuntimeCC());
1457 return C;
Chris Lattner74391b42009-03-22 21:03:39 +00001458}
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001459
Richard Smitha9b21d22012-02-17 06:48:11 +00001460/// isTypeConstant - Determine whether an object of this type can be emitted
1461/// as a constant.
1462///
1463/// If ExcludeCtor is true, the duration when the object's constructor runs
1464/// will not be considered. The caller will need to verify that the object is
1465/// not written to during its construction.
1466bool CodeGenModule::isTypeConstant(QualType Ty, bool ExcludeCtor) {
1467 if (!Ty.isConstant(Context) && !Ty->isReferenceType())
Eli Friedman20e098b2009-12-11 21:23:03 +00001468 return false;
Richard Smitha9b21d22012-02-17 06:48:11 +00001469
David Blaikie4e4d0842012-03-11 07:00:24 +00001470 if (Context.getLangOpts().CPlusPlus) {
Richard Smitha9b21d22012-02-17 06:48:11 +00001471 if (const CXXRecordDecl *Record
1472 = Context.getBaseElementType(Ty)->getAsCXXRecordDecl())
1473 return ExcludeCtor && !Record->hasMutableFields() &&
1474 Record->hasTrivialDestructor();
Eli Friedman20e098b2009-12-11 21:23:03 +00001475 }
Richard Smitha9b21d22012-02-17 06:48:11 +00001476
Eli Friedman20e098b2009-12-11 21:23:03 +00001477 return true;
1478}
1479
Chris Lattner74391b42009-03-22 21:03:39 +00001480/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
1481/// create and return an llvm GlobalVariable with the specified type. If there
1482/// is something in the module with the specified name, return it potentially
1483/// bitcasted to the right type.
1484///
1485/// If D is non-null, it specifies a decl that correspond to this. This is used
1486/// to set the attributes on the global when it is first created.
John McCallf746aa62010-03-19 23:29:14 +00001487llvm::Constant *
Chris Lattner5f9e2722011-07-23 10:55:15 +00001488CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001489 llvm::PointerType *Ty,
Rafael Espindolac532b502011-01-18 21:07:57 +00001490 const VarDecl *D,
1491 bool UnnamedAddr) {
Daniel Dunbar3c827a72008-08-05 23:31:02 +00001492 // Lookup the entry, lazily creating it if necessary.
John McCallf746aa62010-03-19 23:29:14 +00001493 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner99b53612009-03-21 08:03:33 +00001494 if (Entry) {
Benjamin Kramerd48bcb22012-08-22 15:37:55 +00001495 if (WeakRefReferences.erase(Entry)) {
Rafael Espindola6a836702010-03-04 18:17:24 +00001496 if (D && !D->hasAttr<WeakAttr>())
Anders Carlsson7270ee42010-03-23 04:31:31 +00001497 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola6a836702010-03-04 18:17:24 +00001498 }
1499
Rafael Espindolac532b502011-01-18 21:07:57 +00001500 if (UnnamedAddr)
1501 Entry->setUnnamedAddr(true);
1502
Chris Lattner74391b42009-03-22 21:03:39 +00001503 if (Entry->getType() == Ty)
Chris Lattner570585c2009-03-21 09:16:30 +00001504 return Entry;
Mike Stump1eb44332009-09-09 15:08:12 +00001505
Chris Lattner99b53612009-03-21 08:03:33 +00001506 // Make sure the result is of the correct type.
Owen Anderson3c4972d2009-07-29 18:54:39 +00001507 return llvm::ConstantExpr::getBitCast(Entry, Ty);
Daniel Dunbar49988882009-01-13 02:25:00 +00001508 }
Mike Stump1eb44332009-09-09 15:08:12 +00001509
Chris Lattner67b00522009-03-21 09:44:56 +00001510 // This is the first use or definition of a mangled name. If there is a
1511 // deferred decl with this name, remember that we need to emit it at the end
1512 // of the file.
John McCallf746aa62010-03-19 23:29:14 +00001513 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner67b00522009-03-21 09:44:56 +00001514 if (DDI != DeferredDecls.end()) {
1515 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1516 // list, and remove it from DeferredDecls (since we don't need it anymore).
1517 DeferredDeclsToEmit.push_back(DDI->second);
1518 DeferredDecls.erase(DDI);
1519 }
Mike Stump1eb44332009-09-09 15:08:12 +00001520
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00001521 unsigned AddrSpace = GetGlobalVarAddressSpace(D, Ty->getAddressSpace());
Mike Stump1eb44332009-09-09 15:08:12 +00001522 llvm::GlobalVariable *GV =
1523 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
Chris Lattner99b53612009-03-21 08:03:33 +00001524 llvm::GlobalValue::ExternalLinkage,
John McCallf746aa62010-03-19 23:29:14 +00001525 0, MangledName, 0,
Hans Wennborg5e2d5de2012-06-23 11:51:46 +00001526 llvm::GlobalVariable::NotThreadLocal, AddrSpace);
Chris Lattner99b53612009-03-21 08:03:33 +00001527
1528 // Handle things which are present even on external declarations.
Chris Lattner74391b42009-03-22 21:03:39 +00001529 if (D) {
Mike Stumpf5408fe2009-05-16 07:57:57 +00001530 // FIXME: This code is overly simple and should be merged with other global
1531 // handling.
Richard Smitha9b21d22012-02-17 06:48:11 +00001532 GV->setConstant(isTypeConstant(D->getType(), false));
Chris Lattner99b53612009-03-21 08:03:33 +00001533
John McCall110e8e52010-10-29 22:22:43 +00001534 // Set linkage and visibility in case we never see a definition.
Rafael Espindola2beda122013-02-27 02:15:29 +00001535 LinkageInfo LV = D->getLinkageAndVisibility();
Rafael Espindolaf127eb82013-02-27 02:56:45 +00001536 if (LV.getLinkage() != ExternalLinkage) {
John McCall15e310a2011-02-19 02:53:41 +00001537 // Don't set internal linkage on declarations.
John McCall110e8e52010-10-29 22:22:43 +00001538 } else {
1539 if (D->hasAttr<DLLImportAttr>())
1540 GV->setLinkage(llvm::GlobalValue::DLLImportLinkage);
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001541 else if (D->hasAttr<WeakAttr>() || D->isWeakImported())
John McCall110e8e52010-10-29 22:22:43 +00001542 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Chris Lattner99b53612009-03-21 08:03:33 +00001543
John McCallaf146032010-10-30 11:50:40 +00001544 // Set visibility on a declaration only if it's explicit.
Rafael Espindolaf127eb82013-02-27 02:56:45 +00001545 if (LV.isVisibilityExplicit())
1546 GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
John McCall110e8e52010-10-29 22:22:43 +00001547 }
Eli Friedman56ebe502009-04-19 21:05:03 +00001548
Richard Smithb80a16e2013-04-19 16:42:07 +00001549 if (D->getTLSKind()) {
Richard Smithdb4f61f2013-04-22 08:06:17 +00001550 if (D->getTLSKind() == VarDecl::TLS_Dynamic)
1551 CXXThreadLocals.push_back(std::make_pair(D, GV));
Hans Wennborgde981f32012-06-28 08:01:44 +00001552 setTLSMode(GV, *D);
Richard Smithb80a16e2013-04-19 16:42:07 +00001553 }
Chris Lattner74391b42009-03-22 21:03:39 +00001554 }
Mike Stump1eb44332009-09-09 15:08:12 +00001555
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00001556 if (AddrSpace != Ty->getAddressSpace())
1557 return llvm::ConstantExpr::getBitCast(GV, Ty);
1558 else
1559 return GV;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001560}
1561
Chris Lattner74391b42009-03-22 21:03:39 +00001562
Anders Carlsson3bd62022011-01-29 18:20:20 +00001563llvm::GlobalVariable *
Chris Lattner5f9e2722011-07-23 10:55:15 +00001564CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001565 llvm::Type *Ty,
Anders Carlsson3bd62022011-01-29 18:20:20 +00001566 llvm::GlobalValue::LinkageTypes Linkage) {
1567 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
1568 llvm::GlobalVariable *OldGV = 0;
1569
1570
1571 if (GV) {
1572 // Check if the variable has the right type.
1573 if (GV->getType()->getElementType() == Ty)
1574 return GV;
1575
1576 // Because C++ name mangling, the only way we can end up with an already
1577 // existing global with the same name is if it has been declared extern "C".
Nico Weberc5f80462012-10-11 10:13:44 +00001578 assert(GV->isDeclaration() && "Declaration has wrong type!");
Anders Carlsson3bd62022011-01-29 18:20:20 +00001579 OldGV = GV;
1580 }
1581
1582 // Create a new variable.
1583 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
1584 Linkage, 0, Name);
1585
1586 if (OldGV) {
1587 // Replace occurrences of the old variable if needed.
1588 GV->takeName(OldGV);
1589
1590 if (!OldGV->use_empty()) {
1591 llvm::Constant *NewPtrForOldDecl =
1592 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
1593 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
1594 }
1595
1596 OldGV->eraseFromParent();
1597 }
1598
1599 return GV;
1600}
1601
Chris Lattner74391b42009-03-22 21:03:39 +00001602/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
1603/// given global variable. If Ty is non-null and if the global doesn't exist,
Eric Christopher0ff258b2012-04-16 23:55:04 +00001604/// then it will be created with the specified type instead of whatever the
Chris Lattner74391b42009-03-22 21:03:39 +00001605/// normal requested type would be.
1606llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001607 llvm::Type *Ty) {
Chris Lattner74391b42009-03-22 21:03:39 +00001608 assert(D->hasGlobalStorage() && "Not a global variable");
1609 QualType ASTTy = D->getType();
1610 if (Ty == 0)
1611 Ty = getTypes().ConvertTypeForMem(ASTTy);
Mike Stump1eb44332009-09-09 15:08:12 +00001612
Chris Lattner2acc6e32011-07-18 04:24:23 +00001613 llvm::PointerType *PTy =
Peter Collingbourne207f4d82011-03-18 22:38:29 +00001614 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
John McCallf746aa62010-03-19 23:29:14 +00001615
Chris Lattner5f9e2722011-07-23 10:55:15 +00001616 StringRef MangledName = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +00001617 return GetOrCreateLLVMGlobal(MangledName, PTy, D);
Chris Lattner74391b42009-03-22 21:03:39 +00001618}
1619
1620/// CreateRuntimeVariable - Create a new runtime global variable with the
1621/// specified type and name.
1622llvm::Constant *
Chris Lattner2acc6e32011-07-18 04:24:23 +00001623CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001624 StringRef Name) {
John McCall1de4d4e2011-04-07 08:22:57 +00001625 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0,
Rafael Espindolac532b502011-01-18 21:07:57 +00001626 true);
Chris Lattner74391b42009-03-22 21:03:39 +00001627}
1628
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001629void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1630 assert(!D->getInit() && "Cannot emit definite definitions here!");
1631
Douglas Gregor7520bd12009-04-21 19:28:58 +00001632 if (MayDeferGeneration(D)) {
1633 // If we have not seen a reference to this variable yet, place it
1634 // into the deferred declarations table to be emitted if needed
1635 // later.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001636 StringRef MangledName = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +00001637 if (!GetGlobalValue(MangledName)) {
Anders Carlsson555b4bb2009-09-10 23:43:36 +00001638 DeferredDecls[MangledName] = D;
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001639 return;
Douglas Gregor7520bd12009-04-21 19:28:58 +00001640 }
1641 }
1642
1643 // The tentative definition is the only definition.
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001644 EmitGlobalVarDefinition(D);
1645}
1646
Chris Lattner2acc6e32011-07-18 04:24:23 +00001647CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
Ken Dyck06f486e2011-01-18 02:01:14 +00001648 return Context.toCharUnitsFromBits(
Micah Villmow25a6a842012-10-08 16:25:52 +00001649 TheDataLayout.getTypeStoreSizeInBits(Ty));
Ken Dyck687cc4a2010-01-26 13:48:07 +00001650}
1651
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00001652unsigned CodeGenModule::GetGlobalVarAddressSpace(const VarDecl *D,
1653 unsigned AddrSpace) {
1654 if (LangOpts.CUDA && CodeGenOpts.CUDAIsDevice) {
1655 if (D->hasAttr<CUDAConstantAttr>())
1656 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_constant);
1657 else if (D->hasAttr<CUDASharedAttr>())
1658 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_shared);
1659 else
1660 AddrSpace = getContext().getTargetAddressSpace(LangAS::cuda_device);
1661 }
1662
1663 return AddrSpace;
1664}
1665
Richard Smith00249372013-04-06 05:00:46 +00001666template<typename SomeDecl>
1667void CodeGenModule::MaybeHandleStaticInExternC(const SomeDecl *D,
1668 llvm::GlobalValue *GV) {
1669 if (!getLangOpts().CPlusPlus)
1670 return;
1671
1672 // Must have 'used' attribute, or else inline assembly can't rely on
1673 // the name existing.
1674 if (!D->template hasAttr<UsedAttr>())
1675 return;
1676
1677 // Must have internal linkage and an ordinary name.
Rafael Espindola181e3ec2013-05-13 00:12:11 +00001678 if (!D->getIdentifier() || D->getFormalLinkage() != InternalLinkage)
Richard Smith00249372013-04-06 05:00:46 +00001679 return;
1680
1681 // Must be in an extern "C" context. Entities declared directly within
1682 // a record are not extern "C" even if the record is in such a context.
Rafael Espindolad8ffd0b2013-05-05 20:15:21 +00001683 const SomeDecl *First = D->getFirstDeclaration();
1684 if (First->getDeclContext()->isRecord() || !First->isInExternCContext())
Richard Smith00249372013-04-06 05:00:46 +00001685 return;
1686
1687 // OK, this is an internal linkage entity inside an extern "C" linkage
1688 // specification. Make a note of that so we can give it the "expected"
1689 // mangled name if nothing else is using that name.
Richard Smith67972042013-04-06 07:07:44 +00001690 std::pair<StaticExternCMap::iterator, bool> R =
1691 StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
Richard Smith00249372013-04-06 05:00:46 +00001692
1693 // If we have multiple internal linkage entities with the same name
1694 // in extern "C" regions, none of them gets that name.
Richard Smith67972042013-04-06 07:07:44 +00001695 if (!R.second)
1696 R.first->second = 0;
Richard Smith00249372013-04-06 05:00:46 +00001697}
1698
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001699void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
Chris Lattner8f32f712007-07-14 00:23:28 +00001700 llvm::Constant *Init = 0;
Eli Friedman77ba7082008-05-30 19:50:47 +00001701 QualType ASTTy = D->getType();
Richard Smith7ca48502012-02-13 22:16:19 +00001702 CXXRecordDecl *RD = ASTTy->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
1703 bool NeedsGlobalCtor = false;
1704 bool NeedsGlobalDtor = RD && !RD->hasTrivialDestructor();
Mike Stump1eb44332009-09-09 15:08:12 +00001705
Richard Smith2d6a5672012-01-14 04:30:29 +00001706 const VarDecl *InitDecl;
1707 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001708
Anders Carlsson3bb92692010-01-26 17:43:42 +00001709 if (!InitExpr) {
Eli Friedmancd5f4aa2008-05-30 20:39:54 +00001710 // This is a tentative definition; tentative definitions are
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001711 // implicitly initialized with { 0 }.
1712 //
1713 // Note that tentative definitions are only emitted at the end of
1714 // a translation unit, so they should never have incomplete
1715 // type. In addition, EmitTentativeDefinition makes sure that we
1716 // never attempt to emit a tentative definition if a real one
1717 // exists. A use may still exists, however, so we still may need
1718 // to do a RAUW.
1719 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
Anders Carlssonb0d0ea02009-08-02 21:18:22 +00001720 Init = EmitNullConstant(D->getType());
Eli Friedman77ba7082008-05-30 19:50:47 +00001721 } else {
Richard Smith7c3e6152013-06-12 22:31:48 +00001722 initializedGlobalDecl = GlobalDecl(D);
1723 Init = EmitConstantInit(*InitDecl);
Sebastian Redl19b1a6e2012-02-25 20:51:20 +00001724
Fariborz Jahanian4904bf42012-06-26 16:06:38 +00001725 if (!Init) {
Anders Carlsson3bb92692010-01-26 17:43:42 +00001726 QualType T = InitExpr->getType();
Douglas Gregorc446d182010-05-05 20:15:55 +00001727 if (D->getType()->isReferenceType())
1728 T = D->getType();
Richard Smith2d6a5672012-01-14 04:30:29 +00001729
David Blaikie4e4d0842012-03-11 07:00:24 +00001730 if (getLangOpts().CPlusPlus) {
Anders Carlsson89ed31d2009-08-08 23:24:23 +00001731 Init = EmitNullConstant(T);
Richard Smith7ca48502012-02-13 22:16:19 +00001732 NeedsGlobalCtor = true;
Anders Carlsson89ed31d2009-08-08 23:24:23 +00001733 } else {
1734 ErrorUnsupported(D, "static initializer");
1735 Init = llvm::UndefValue::get(getTypes().ConvertType(T));
1736 }
John McCallbf40cb52010-07-15 23:40:35 +00001737 } else {
1738 // We don't need an initializer, so remove the entry for the delayed
Richard Smith7ca48502012-02-13 22:16:19 +00001739 // initializer position (just in case this entry was delayed) if we
1740 // also don't need to register a destructor.
David Blaikie4e4d0842012-03-11 07:00:24 +00001741 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
John McCallbf40cb52010-07-15 23:40:35 +00001742 DelayedCXXInitPosition.erase(D);
Eli Friedman6e656f42009-02-20 01:18:21 +00001743 }
Eli Friedman77ba7082008-05-30 19:50:47 +00001744 }
Eli Friedman77ba7082008-05-30 19:50:47 +00001745
Chris Lattner2acc6e32011-07-18 04:24:23 +00001746 llvm::Type* InitType = Init->getType();
Chris Lattner570585c2009-03-21 09:16:30 +00001747 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
Mike Stump1eb44332009-09-09 15:08:12 +00001748
Chris Lattner570585c2009-03-21 09:16:30 +00001749 // Strip off a bitcast if we got one back.
1750 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
Chris Lattner9d4a15f2009-07-16 16:48:25 +00001751 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
1752 // all zero index gep.
1753 CE->getOpcode() == llvm::Instruction::GetElementPtr);
Chris Lattner570585c2009-03-21 09:16:30 +00001754 Entry = CE->getOperand(0);
1755 }
Mike Stump1eb44332009-09-09 15:08:12 +00001756
Chris Lattner570585c2009-03-21 09:16:30 +00001757 // Entry is now either a Function or GlobalVariable.
1758 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00001759
Chris Lattner570585c2009-03-21 09:16:30 +00001760 // We have a definition after a declaration with the wrong type.
1761 // We must make a new GlobalVariable* and update everything that used OldGV
1762 // (a declaration or tentative definition) with the new GlobalVariable*
1763 // (which will be a definition).
1764 //
1765 // This happens if there is a prototype for a global (e.g.
1766 // "extern int x[];") and then a definition of a different type (e.g.
1767 // "int x[10];"). This also happens when an initializer has a different type
1768 // from the type of the global (this happens with unions).
Chris Lattner570585c2009-03-21 09:16:30 +00001769 if (GV == 0 ||
1770 GV->getType()->getElementType() != InitType ||
Peter Collingbourne207f4d82011-03-18 22:38:29 +00001771 GV->getType()->getAddressSpace() !=
Peter Collingbourne4dc34eb2012-05-20 21:08:35 +00001772 GetGlobalVarAddressSpace(D, getContext().getTargetAddressSpace(ASTTy))) {
Mike Stump1eb44332009-09-09 15:08:12 +00001773
John McCallf746aa62010-03-19 23:29:14 +00001774 // Move the old entry aside so that we'll create a new one.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001775 Entry->setName(StringRef());
Daniel Dunbar232350d2009-02-19 05:36:41 +00001776
Chris Lattner570585c2009-03-21 09:16:30 +00001777 // Make a new global with the correct type, this is now guaranteed to work.
1778 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
Chris Lattner0558e792009-03-21 09:25:43 +00001779
Eli Friedman77ba7082008-05-30 19:50:47 +00001780 // Replace all uses of the old global with the new global
Mike Stump1eb44332009-09-09 15:08:12 +00001781 llvm::Constant *NewPtrForOldDecl =
Owen Anderson3c4972d2009-07-29 18:54:39 +00001782 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
Chris Lattner570585c2009-03-21 09:16:30 +00001783 Entry->replaceAllUsesWith(NewPtrForOldDecl);
Eli Friedman77ba7082008-05-30 19:50:47 +00001784
1785 // Erase the old global, since it is no longer used.
Chris Lattner570585c2009-03-21 09:16:30 +00001786 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
Chris Lattner8f32f712007-07-14 00:23:28 +00001787 }
Devang Patel8e53e722007-10-26 16:31:40 +00001788
Richard Smith00249372013-04-06 05:00:46 +00001789 MaybeHandleStaticInExternC(D, GV);
1790
Julien Lerouge77f68bb2011-09-09 22:41:49 +00001791 if (D->hasAttr<AnnotateAttr>())
1792 AddGlobalAnnotations(D, GV);
Nate Begeman8bd4afe2008-04-19 04:17:09 +00001793
Chris Lattner88a69ad2007-07-13 05:13:43 +00001794 GV->setInitializer(Init);
Chris Lattnere78b86f2009-08-05 05:20:29 +00001795
1796 // If it is safe to mark the global 'constant', do so now.
Richard Smitha9b21d22012-02-17 06:48:11 +00001797 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
1798 isTypeConstant(D->getType(), true));
Mike Stump1eb44332009-09-09 15:08:12 +00001799
Ken Dyck8b752f12010-01-27 17:10:57 +00001800 GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
Richard Smitha9b21d22012-02-17 06:48:11 +00001801
Chris Lattner88a69ad2007-07-13 05:13:43 +00001802 // Set the llvm linkage type as appropriate.
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001803 llvm::GlobalValue::LinkageTypes Linkage =
Eli Friedman07369dd2013-07-01 20:22:57 +00001804 GetLLVMLinkageVarDefinition(D, GV->isConstant());
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001805 GV->setLinkage(Linkage);
1806 if (Linkage == llvm::GlobalVariable::CommonLinkage)
Chris Lattnere78b86f2009-08-05 05:20:29 +00001807 // common vars aren't constant even if declared const.
1808 GV->setConstant(false);
Daniel Dunbar7e714cd2009-04-10 20:26:50 +00001809
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001810 SetCommonAttributes(D, GV);
Daniel Dunbar04d40782009-04-14 06:00:08 +00001811
John McCall3030eb82010-11-06 09:44:32 +00001812 // Emit the initializer function if necessary.
Richard Smith7ca48502012-02-13 22:16:19 +00001813 if (NeedsGlobalCtor || NeedsGlobalDtor)
1814 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
John McCall3030eb82010-11-06 09:44:32 +00001815
Kostya Serebryany05c5ebc2012-08-21 06:53:28 +00001816 // If we are compiling with ASan, add metadata indicating dynamically
1817 // initialized globals.
Will Dietz4f45bc02013-01-18 11:30:38 +00001818 if (SanOpts.Address && NeedsGlobalCtor) {
Kostya Serebryany05c5ebc2012-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 Gupta686226b2008-06-05 08:59:10 +00001828 // Emit global variable debug information.
Eric Christopher73fb3502011-10-13 21:45:18 +00001829 if (CGDebugInfo *DI = getModuleDebugInfo())
Douglas Gregor4cdad312012-10-23 20:05:01 +00001830 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
Alexey Samsonovfd00eec2012-05-04 07:39:27 +00001831 DI->EmitGlobalVariable(GV, D);
Chris Lattner88a69ad2007-07-13 05:13:43 +00001832}
Reid Spencer5f016e22007-07-11 17:01:13 +00001833
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001834llvm::GlobalValue::LinkageTypes
Eli Friedman07369dd2013-07-01 20:22:57 +00001835CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D, bool isConstant) {
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001836 GVALinkage Linkage = getContext().GetGVALinkageForVariable(D);
1837 if (Linkage == GVA_Internal)
1838 return llvm::Function::InternalLinkage;
1839 else if (D->hasAttr<DLLImportAttr>())
1840 return llvm::Function::DLLImportLinkage;
1841 else if (D->hasAttr<DLLExportAttr>())
1842 return llvm::Function::DLLExportLinkage;
Reid Klecknera7225342013-05-20 14:02:37 +00001843 else if (D->hasAttr<SelectAnyAttr>()) {
1844 // selectany symbols are externally visible, so use weak instead of
1845 // linkonce. MSVC optimizes away references to const selectany globals, so
1846 // all definitions should be the same and ODR linkage should be used.
1847 // http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx
1848 return llvm::GlobalVariable::WeakODRLinkage;
1849 } else if (D->hasAttr<WeakAttr>()) {
Eli Friedman07369dd2013-07-01 20:22:57 +00001850 if (isConstant)
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001851 return llvm::GlobalVariable::WeakODRLinkage;
1852 else
1853 return llvm::GlobalVariable::WeakAnyLinkage;
1854 } else if (Linkage == GVA_TemplateInstantiation ||
1855 Linkage == GVA_ExplicitTemplateInstantiation)
John McCall99ace162011-04-12 01:46:54 +00001856 return llvm::GlobalVariable::WeakODRLinkage;
David Blaikie4e4d0842012-03-11 07:00:24 +00001857 else if (!getLangOpts().CPlusPlus &&
Eric Christophera6cf1e72010-12-02 02:45:55 +00001858 ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) ||
1859 D->getAttr<CommonAttr>()) &&
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001860 !D->hasExternalStorage() && !D->getInit() &&
Richard Smith38afbc72013-04-13 02:43:54 +00001861 !D->getAttr<SectionAttr>() && !D->getTLSKind() &&
Fariborz Jahanianab27d6e2011-06-20 17:50:03 +00001862 !D->getAttr<WeakImportAttr>()) {
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001863 // Thread local vars aren't considered common linkage.
1864 return llvm::GlobalVariable::CommonLinkage;
Bill Wendling4e3b54b2013-05-02 19:18:03 +00001865 } else if (D->getTLSKind() == VarDecl::TLS_Dynamic &&
1866 getTarget().getTriple().isMacOSX())
1867 // On Darwin, the backing variable for a C++11 thread_local variable always
1868 // has internal linkage; all accesses should just be calls to the
1869 // Itanium-specified entry point, which has the normal linkage of the
1870 // variable.
1871 return llvm::GlobalValue::InternalLinkage;
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001872 return llvm::GlobalVariable::ExternalLinkage;
1873}
1874
John McCalla923c972012-12-12 22:21:47 +00001875/// Replace the uses of a function that was declared with a non-proto type.
1876/// We want to silently drop extra arguments from call sites
1877static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
1878 llvm::Function *newFn) {
1879 // Fast path.
1880 if (old->use_empty()) return;
1881
1882 llvm::Type *newRetTy = newFn->getReturnType();
1883 SmallVector<llvm::Value*, 4> newArgs;
1884
1885 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
1886 ui != ue; ) {
1887 llvm::Value::use_iterator use = ui++; // Increment before the use is erased.
1888 llvm::User *user = *use;
1889
1890 // Recognize and replace uses of bitcasts. Most calls to
1891 // unprototyped functions will use bitcasts.
1892 if (llvm::ConstantExpr *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
1893 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
1894 replaceUsesOfNonProtoConstant(bitcast, newFn);
1895 continue;
1896 }
1897
1898 // Recognize calls to the function.
1899 llvm::CallSite callSite(user);
1900 if (!callSite) continue;
1901 if (!callSite.isCallee(use)) continue;
1902
1903 // If the return types don't match exactly, then we can't
1904 // transform this call unless it's dead.
1905 if (callSite->getType() != newRetTy && !callSite->use_empty())
1906 continue;
1907
1908 // Get the call site's attribute list.
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001909 SmallVector<llvm::AttributeSet, 8> newAttrs;
John McCalla923c972012-12-12 22:21:47 +00001910 llvm::AttributeSet oldAttrs = callSite.getAttributes();
1911
1912 // Collect any return attributes from the call.
Bill Wendlinga37ce612013-01-21 21:57:40 +00001913 if (oldAttrs.hasAttributes(llvm::AttributeSet::ReturnIndex))
Bill Wendlinged01f842013-01-21 22:45:00 +00001914 newAttrs.push_back(
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001915 llvm::AttributeSet::get(newFn->getContext(),
1916 oldAttrs.getRetAttributes()));
John McCalla923c972012-12-12 22:21:47 +00001917
1918 // If the function was passed too few arguments, don't transform.
1919 unsigned newNumArgs = newFn->arg_size();
1920 if (callSite.arg_size() < newNumArgs) continue;
1921
1922 // If extra arguments were passed, we silently drop them.
1923 // If any of the types mismatch, we don't transform.
1924 unsigned argNo = 0;
1925 bool dontTransform = false;
1926 for (llvm::Function::arg_iterator ai = newFn->arg_begin(),
1927 ae = newFn->arg_end(); ai != ae; ++ai, ++argNo) {
1928 if (callSite.getArgument(argNo)->getType() != ai->getType()) {
1929 dontTransform = true;
1930 break;
1931 }
1932
1933 // Add any parameter attributes.
Bill Wendling89530e42013-01-23 06:15:10 +00001934 if (oldAttrs.hasAttributes(argNo + 1))
1935 newAttrs.
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001936 push_back(llvm::
1937 AttributeSet::get(newFn->getContext(),
1938 oldAttrs.getParamAttributes(argNo + 1)));
John McCalla923c972012-12-12 22:21:47 +00001939 }
1940 if (dontTransform)
1941 continue;
1942
Bill Wendlinge67e4c92013-01-18 21:26:07 +00001943 if (oldAttrs.hasAttributes(llvm::AttributeSet::FunctionIndex))
Bill Wendlingb263bdf2013-01-27 02:46:53 +00001944 newAttrs.push_back(llvm::AttributeSet::get(newFn->getContext(),
1945 oldAttrs.getFnAttributes()));
John McCalla923c972012-12-12 22:21:47 +00001946
1947 // Okay, we can transform this. Create the new call instruction and copy
1948 // over the required information.
1949 newArgs.append(callSite.arg_begin(), callSite.arg_begin() + argNo);
1950
1951 llvm::CallSite newCall;
1952 if (callSite.isCall()) {
1953 newCall = llvm::CallInst::Create(newFn, newArgs, "",
1954 callSite.getInstruction());
1955 } else {
1956 llvm::InvokeInst *oldInvoke =
1957 cast<llvm::InvokeInst>(callSite.getInstruction());
1958 newCall = llvm::InvokeInst::Create(newFn,
1959 oldInvoke->getNormalDest(),
1960 oldInvoke->getUnwindDest(),
1961 newArgs, "",
1962 callSite.getInstruction());
1963 }
1964 newArgs.clear(); // for the next iteration
1965
1966 if (!newCall->getType()->isVoidTy())
1967 newCall->takeName(callSite.getInstruction());
1968 newCall.setAttributes(
1969 llvm::AttributeSet::get(newFn->getContext(), newAttrs));
1970 newCall.setCallingConv(callSite.getCallingConv());
1971
1972 // Finally, remove the old call, replacing any uses with the new one.
1973 if (!callSite->use_empty())
1974 callSite->replaceAllUsesWith(newCall.getInstruction());
1975
1976 // Copy debug location attached to CI.
1977 if (!callSite->getDebugLoc().isUnknown())
1978 newCall->setDebugLoc(callSite->getDebugLoc());
1979 callSite->eraseFromParent();
1980 }
1981}
1982
Chris Lattnerbdb01322009-05-05 06:16:31 +00001983/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
1984/// implement a function with no prototype, e.g. "int foo() {}". If there are
1985/// existing call uses of the old function in the module, this adjusts them to
1986/// call the new function directly.
1987///
1988/// This is not just a cleanup: the always_inline pass requires direct calls to
1989/// functions to be able to inline them. If there is a bitcast in the way, it
1990/// won't inline them. Instcombine normally deletes these calls, but it isn't
1991/// run at -O0.
1992static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
1993 llvm::Function *NewFn) {
1994 // If we're redefining a global as a function, don't transform it.
John McCalla923c972012-12-12 22:21:47 +00001995 if (!isa<llvm::Function>(Old)) return;
Mike Stump1eb44332009-09-09 15:08:12 +00001996
John McCalla923c972012-12-12 22:21:47 +00001997 replaceUsesOfNonProtoConstant(Old, NewFn);
Chris Lattnerbdb01322009-05-05 06:16:31 +00001998}
1999
Rafael Espindola02503932012-03-08 15:51:03 +00002000void CodeGenModule::HandleCXXStaticMemberVarInstantiation(VarDecl *VD) {
2001 TemplateSpecializationKind TSK = VD->getTemplateSpecializationKind();
2002 // If we have a definition, this might be a deferred decl. If the
2003 // instantiation is explicit, make sure we emit it at the end.
2004 if (VD->getDefinition() && TSK == TSK_ExplicitInstantiationDefinition)
2005 GetAddrOfGlobalVar(VD);
Argyrios Kyrtzidisafda9052013-02-24 00:05:01 +00002006
2007 EmitTopLevelDecl(VD);
Rafael Espindola234fe652012-03-05 10:54:55 +00002008}
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00002009
Chris Lattnerb4880ba2009-05-12 21:21:08 +00002010void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
Chris Lattnerb4880ba2009-05-12 21:21:08 +00002011 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
John McCalld26bc762011-03-09 04:27:21 +00002012
John McCall1f6f9612011-03-09 08:12:35 +00002013 // Compute the function info and LLVM type.
John McCallde5d3c72012-02-17 03:33:10 +00002014 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
2015 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
John McCalld26bc762011-03-09 04:27:21 +00002016
Chris Lattner9fa959d2009-05-12 20:58:15 +00002017 // Get or create the prototype for the function.
Chris Lattnerb4880ba2009-05-12 21:21:08 +00002018 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
Mike Stump1eb44332009-09-09 15:08:12 +00002019
Chris Lattner0558e792009-03-21 09:25:43 +00002020 // Strip off a bitcast if we got one back.
2021 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
2022 assert(CE->getOpcode() == llvm::Instruction::BitCast);
2023 Entry = CE->getOperand(0);
2024 }
Mike Stump1eb44332009-09-09 15:08:12 +00002025
2026
Chris Lattner0558e792009-03-21 09:25:43 +00002027 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00002028 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00002029
Daniel Dunbar42745812009-03-09 23:53:08 +00002030 // If the types mismatch then we have to rewrite the definition.
Chris Lattnerbdb01322009-05-05 06:16:31 +00002031 assert(OldFn->isDeclaration() &&
Chris Lattner0558e792009-03-21 09:25:43 +00002032 "Shouldn't replace non-declaration");
Chris Lattner34809502009-03-21 08:53:37 +00002033
Chris Lattner62b33ea2009-03-21 08:38:50 +00002034 // F is the Function* for the one with the wrong type, we must make a new
2035 // Function* and update everything that used F (a declaration) with the new
2036 // Function* (which will be a definition).
2037 //
2038 // This happens if there is a prototype for a function
2039 // (e.g. "int f()") and then a definition of a different type
John McCallf746aa62010-03-19 23:29:14 +00002040 // (e.g. "int f(int x)"). Move the old function aside so that it
2041 // doesn't interfere with GetAddrOfFunction.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002042 OldFn->setName(StringRef());
Chris Lattnerb4880ba2009-05-12 21:21:08 +00002043 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
Mike Stump1eb44332009-09-09 15:08:12 +00002044
John McCalla923c972012-12-12 22:21:47 +00002045 // This might be an implementation of a function without a
2046 // prototype, in which case, try to do special replacement of
2047 // calls which match the new prototype. The really key thing here
2048 // is that we also potentially drop arguments from the call site
2049 // so as to make a direct call, which makes the inliner happier
2050 // and suppresses a number of optimizer warnings (!) about
2051 // dropping arguments.
2052 if (!OldFn->use_empty()) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00002053 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
Chris Lattner9fa959d2009-05-12 20:58:15 +00002054 OldFn->removeDeadConstantUsers();
2055 }
Mike Stump1eb44332009-09-09 15:08:12 +00002056
Chris Lattner62b33ea2009-03-21 08:38:50 +00002057 // Replace uses of F with the Function we will endow with a body.
Chris Lattnerbdb01322009-05-05 06:16:31 +00002058 if (!Entry->use_empty()) {
Mike Stump1eb44332009-09-09 15:08:12 +00002059 llvm::Constant *NewPtrForOldDecl =
Owen Anderson3c4972d2009-07-29 18:54:39 +00002060 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
Chris Lattnerbdb01322009-05-05 06:16:31 +00002061 Entry->replaceAllUsesWith(NewPtrForOldDecl);
2062 }
Mike Stump1eb44332009-09-09 15:08:12 +00002063
Chris Lattner62b33ea2009-03-21 08:38:50 +00002064 // Ok, delete the old function now, which is dead.
Chris Lattnerbdb01322009-05-05 06:16:31 +00002065 OldFn->eraseFromParent();
Mike Stump1eb44332009-09-09 15:08:12 +00002066
Chris Lattner0558e792009-03-21 09:25:43 +00002067 Entry = NewFn;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00002068 }
Mike Stump1eb44332009-09-09 15:08:12 +00002069
John McCall112c9672010-11-02 21:04:24 +00002070 // We need to set linkage and visibility on the function before
2071 // generating code for it because various parts of IR generation
2072 // want to propagate this information down (e.g. to local static
2073 // declarations).
Chris Lattner0558e792009-03-21 09:25:43 +00002074 llvm::Function *Fn = cast<llvm::Function>(Entry);
Peter Collingbourne144a31f2013-06-05 17:49:37 +00002075 setFunctionLinkage(GD, Fn);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00002076
John McCall112c9672010-11-02 21:04:24 +00002077 // FIXME: this is redundant with part of SetFunctionDefinitionAttributes
Anders Carlsson0ffeaad2011-01-29 19:39:23 +00002078 setGlobalVisibility(Fn, D);
John McCall112c9672010-11-02 21:04:24 +00002079
Richard Smith00249372013-04-06 05:00:46 +00002080 MaybeHandleStaticInExternC(D, Fn);
2081
John McCalld26bc762011-03-09 04:27:21 +00002082 CodeGenFunction(*this).GenerateCode(D, Fn, FI);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +00002083
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002084 SetFunctionDefinitionAttributes(D, Fn);
2085 SetLLVMFunctionAttributesForDefinition(D, Fn);
Mike Stump1eb44332009-09-09 15:08:12 +00002086
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002087 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
Daniel Dunbar219df662008-09-08 23:44:31 +00002088 AddGlobalCtor(Fn, CA->getPriority());
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002089 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
Daniel Dunbar219df662008-09-08 23:44:31 +00002090 AddGlobalDtor(Fn, DA->getPriority());
Julien Lerouge77f68bb2011-09-09 22:41:49 +00002091 if (D->hasAttr<AnnotateAttr>())
2092 AddGlobalAnnotations(D, Fn);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00002093}
2094
John McCallf746aa62010-03-19 23:29:14 +00002095void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
2096 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002097 const AliasAttr *AA = D->getAttr<AliasAttr>();
Chris Lattnerbd532712009-03-22 21:47:11 +00002098 assert(AA && "Not an alias?");
2099
Chris Lattner5f9e2722011-07-23 10:55:15 +00002100 StringRef MangledName = getMangledName(GD);
Mike Stump1eb44332009-09-09 15:08:12 +00002101
John McCallf746aa62010-03-19 23:29:14 +00002102 // If there is a definition in the module, then it wins over the alias.
2103 // This is dubious, but allow it to be safe. Just ignore the alias.
2104 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
2105 if (Entry && !Entry->isDeclaration())
2106 return;
2107
Chris Lattner2acc6e32011-07-18 04:24:23 +00002108 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
Chris Lattnerbd532712009-03-22 21:47:11 +00002109
2110 // Create a reference to the named value. This ensures that it is emitted
2111 // if a deferred decl.
2112 llvm::Constant *Aliasee;
2113 if (isa<llvm::FunctionType>(DeclTy))
Alex Rosenbergc857ce82012-10-05 23:12:53 +00002114 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
Anders Carlsson1faa89f2011-02-05 04:35:53 +00002115 /*ForVTable=*/false);
Chris Lattnerbd532712009-03-22 21:47:11 +00002116 else
John McCallf746aa62010-03-19 23:29:14 +00002117 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Owen Anderson96e0fc72009-07-29 22:16:19 +00002118 llvm::PointerType::getUnqual(DeclTy), 0);
Chris Lattnerbd532712009-03-22 21:47:11 +00002119
2120 // Create the new alias itself, but don't set a name yet.
Mike Stump1eb44332009-09-09 15:08:12 +00002121 llvm::GlobalValue *GA =
Chris Lattnerbd532712009-03-22 21:47:11 +00002122 new llvm::GlobalAlias(Aliasee->getType(),
2123 llvm::Function::ExternalLinkage,
2124 "", Aliasee, &getModule());
Mike Stump1eb44332009-09-09 15:08:12 +00002125
Chris Lattnerbd532712009-03-22 21:47:11 +00002126 if (Entry) {
John McCallf746aa62010-03-19 23:29:14 +00002127 assert(Entry->isDeclaration());
2128
Chris Lattnerbd532712009-03-22 21:47:11 +00002129 // If there is a declaration in the module, then we had an extern followed
2130 // by the alias, as in:
2131 // extern int test6();
2132 // ...
2133 // int test6() __attribute__((alias("test7")));
2134 //
2135 // Remove it and replace uses of it with the alias.
John McCallf746aa62010-03-19 23:29:14 +00002136 GA->takeName(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00002137
Owen Anderson3c4972d2009-07-29 18:54:39 +00002138 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
Chris Lattnerbd532712009-03-22 21:47:11 +00002139 Entry->getType()));
Chris Lattnerbd532712009-03-22 21:47:11 +00002140 Entry->eraseFromParent();
John McCallf746aa62010-03-19 23:29:14 +00002141 } else {
Anders Carlsson9a20d552010-06-22 16:16:50 +00002142 GA->setName(MangledName);
Chris Lattnerbd532712009-03-22 21:47:11 +00002143 }
Mike Stump1eb44332009-09-09 15:08:12 +00002144
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002145 // Set attributes which are particular to an alias; this is a
2146 // specialization of the attributes which may be set on a global
2147 // variable/function.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00002148 if (D->hasAttr<DLLExportAttr>()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002149 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2150 // The dllexport attribute is ignored for undefined symbols.
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +00002151 if (FD->hasBody())
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002152 GA->setLinkage(llvm::Function::DLLExportLinkage);
2153 } else {
2154 GA->setLinkage(llvm::Function::DLLExportLinkage);
2155 }
Mike Stump1eb44332009-09-09 15:08:12 +00002156 } else if (D->hasAttr<WeakAttr>() ||
Rafael Espindola11e8ce72010-02-23 22:00:30 +00002157 D->hasAttr<WeakRefAttr>() ||
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00002158 D->isWeakImported()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +00002159 GA->setLinkage(llvm::Function::WeakAnyLinkage);
2160 }
2161
2162 SetCommonAttributes(D, GA);
Chris Lattnerbd532712009-03-22 21:47:11 +00002163}
2164
Benjamin Kramer8dd55a32011-07-14 17:45:50 +00002165llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
Chris Lattner2d3ba4f2011-07-23 17:14:25 +00002166 ArrayRef<llvm::Type*> Tys) {
Jay Foaddf983a82011-07-12 14:06:48 +00002167 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
Benjamin Kramer8dd55a32011-07-14 17:45:50 +00002168 Tys);
Chris Lattner7acda7c2007-12-18 00:25:38 +00002169}
Chris Lattnerbef20ac2007-08-31 04:31:45 +00002170
Daniel Dunbar1d552912009-07-23 22:52:48 +00002171static llvm::StringMapEntry<llvm::Constant*> &
2172GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
2173 const StringLiteral *Literal,
Daniel Dunbar70ee9752009-07-23 23:41:22 +00002174 bool TargetIsLSB,
Daniel Dunbar1d552912009-07-23 22:52:48 +00002175 bool &IsUTF16,
2176 unsigned &StringLength) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00002177 StringRef String = Literal->getString();
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00002178 unsigned NumBytes = String.size();
Daniel Dunbar1d552912009-07-23 22:52:48 +00002179
Daniel Dunbarf015b032009-09-22 10:03:52 +00002180 // Check for simple case.
2181 if (!Literal->containsNonAsciiOrNull()) {
2182 StringLength = NumBytes;
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00002183 return Map.GetOrCreateValue(String);
Daniel Dunbarf015b032009-09-22 10:03:52 +00002184 }
2185
Bill Wendling84392d02012-03-30 00:26:17 +00002186 // Otherwise, convert the UTF8 literals into a string of shorts.
2187 IsUTF16 = true;
2188
2189 SmallVector<UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
Roman Divacky31ba6132012-09-06 15:59:27 +00002190 const UTF8 *FromPtr = (const UTF8 *)String.data();
Daniel Dunbar1d552912009-07-23 22:52:48 +00002191 UTF16 *ToPtr = &ToBuf[0];
Mike Stump1eb44332009-09-09 15:08:12 +00002192
Fariborz Jahaniane7ddfb92010-09-07 19:57:04 +00002193 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
2194 &ToPtr, ToPtr + NumBytes,
2195 strictConversion);
Mike Stump1eb44332009-09-09 15:08:12 +00002196
Daniel Dunbar70ee9752009-07-23 23:41:22 +00002197 // ConvertUTF8toUTF16 returns the length in ToPtr.
Daniel Dunbar1d552912009-07-23 22:52:48 +00002198 StringLength = ToPtr - &ToBuf[0];
Daniel Dunbar70ee9752009-07-23 23:41:22 +00002199
Bill Wendling84392d02012-03-30 00:26:17 +00002200 // Add an explicit null.
2201 *ToPtr = 0;
2202 return Map.
2203 GetOrCreateValue(StringRef(reinterpret_cast<const char *>(ToBuf.data()),
2204 (StringLength + 1) * 2));
Daniel Dunbar1d552912009-07-23 22:52:48 +00002205}
2206
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002207static llvm::StringMapEntry<llvm::Constant*> &
2208GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map,
Bill Wendling8322c232012-03-29 22:12:09 +00002209 const StringLiteral *Literal,
2210 unsigned &StringLength) {
2211 StringRef String = Literal->getString();
2212 StringLength = String.size();
2213 return Map.GetOrCreateValue(String);
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002214}
2215
Daniel Dunbar1d552912009-07-23 22:52:48 +00002216llvm::Constant *
2217CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
2218 unsigned StringLength = 0;
2219 bool isUTF16 = false;
2220 llvm::StringMapEntry<llvm::Constant*> &Entry =
Mike Stump1eb44332009-09-09 15:08:12 +00002221 GetConstantCFStringEntry(CFConstantStringMap, Literal,
Micah Villmow25a6a842012-10-08 16:25:52 +00002222 getDataLayout().isLittleEndian(),
Daniel Dunbar70ee9752009-07-23 23:41:22 +00002223 isUTF16, StringLength);
Mike Stump1eb44332009-09-09 15:08:12 +00002224
Daniel Dunbar1d552912009-07-23 22:52:48 +00002225 if (llvm::Constant *C = Entry.getValue())
2226 return C;
Mike Stump1eb44332009-09-09 15:08:12 +00002227
Chris Lattner8b418682012-02-07 00:39:47 +00002228 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
Daniel Dunbar3e9df992008-08-23 18:37:06 +00002229 llvm::Constant *Zeros[] = { Zero, Zero };
Fariborz Jahanian428edb72013-04-16 15:25:39 +00002230 llvm::Value *V;
2231
Chris Lattner9d4a15f2009-07-16 16:48:25 +00002232 // If we don't already have it, get __CFConstantStringClassReference.
Anders Carlssonc9e20912007-08-21 00:21:21 +00002233 if (!CFConstantStringClassRef) {
Chris Lattner2acc6e32011-07-18 04:24:23 +00002234 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00002235 Ty = llvm::ArrayType::get(Ty, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00002236 llvm::Constant *GV = CreateRuntimeVariable(Ty,
Chris Lattner9d4a15f2009-07-16 16:48:25 +00002237 "__CFConstantStringClassReference");
Daniel Dunbar3e9df992008-08-23 18:37:06 +00002238 // Decay array -> ptr
Fariborz Jahanian428edb72013-04-16 15:25:39 +00002239 V = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2240 CFConstantStringClassRef = V;
Anders Carlssonc9e20912007-08-21 00:21:21 +00002241 }
Fariborz Jahanian428edb72013-04-16 15:25:39 +00002242 else
2243 V = CFConstantStringClassRef;
Mike Stump1eb44332009-09-09 15:08:12 +00002244
Anders Carlssone3daa762008-11-15 18:54:24 +00002245 QualType CFTy = getContext().getCFConstantStringType();
Daniel Dunbar3e9df992008-08-23 18:37:06 +00002246
Chris Lattner2acc6e32011-07-18 04:24:23 +00002247 llvm::StructType *STy =
Anders Carlssone3daa762008-11-15 18:54:24 +00002248 cast<llvm::StructType>(getTypes().ConvertType(CFTy));
2249
Benjamin Kramer1d236ab2011-10-15 12:20:02 +00002250 llvm::Constant *Fields[4];
Douglas Gregor44b43212008-12-11 16:49:14 +00002251
Anders Carlssonc9e20912007-08-21 00:21:21 +00002252 // Class pointer.
Fariborz Jahanian428edb72013-04-16 15:25:39 +00002253 Fields[0] = cast<llvm::ConstantExpr>(V);
Mike Stump1eb44332009-09-09 15:08:12 +00002254
Anders Carlssonc9e20912007-08-21 00:21:21 +00002255 // Flags.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002256 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
Mike Stump1eb44332009-09-09 15:08:12 +00002257 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
Anders Carlsson5add6832009-08-16 05:55:31 +00002258 llvm::ConstantInt::get(Ty, 0x07C8);
2259
Anders Carlssonc9e20912007-08-21 00:21:21 +00002260 // String pointer.
Bill Wendling84392d02012-03-30 00:26:17 +00002261 llvm::Constant *C = 0;
2262 if (isUTF16) {
2263 ArrayRef<uint16_t> Arr =
David Greene5ba58a12013-01-15 22:09:41 +00002264 llvm::makeArrayRef<uint16_t>(reinterpret_cast<uint16_t*>(
2265 const_cast<char *>(Entry.getKey().data())),
Bill Wendling84392d02012-03-30 00:26:17 +00002266 Entry.getKey().size() / 2);
2267 C = llvm::ConstantDataArray::get(VMContext, Arr);
2268 } else {
2269 C = llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
2270 }
Daniel Dunbara9668e02009-04-03 00:57:44 +00002271
Chris Lattner95b851e2009-07-16 05:03:48 +00002272 llvm::GlobalValue::LinkageTypes Linkage;
Bill Wendling1bf7a3f2012-01-10 08:46:39 +00002273 if (isUTF16)
Chris Lattner278b9f02009-10-14 05:55:45 +00002274 // FIXME: why do utf strings get "_" labels instead of "L" labels?
Chris Lattner95b851e2009-07-16 05:03:48 +00002275 Linkage = llvm::GlobalValue::InternalLinkage;
Bill Wendling1bf7a3f2012-01-10 08:46:39 +00002276 else
Rafael Espindola584acf22011-03-14 17:55:00 +00002277 // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error
2278 // when using private linkage. It is not clear if this is a bug in ld
2279 // or a reasonable new restriction.
Rafael Espindoladc0f1372011-03-14 21:08:19 +00002280 Linkage = llvm::GlobalValue::LinkerPrivateLinkage;
Chris Lattner278b9f02009-10-14 05:55:45 +00002281
Bill Wendling1bf7a3f2012-01-10 08:46:39 +00002282 // Note: -fwritable-strings doesn't make the backing store strings of
2283 // CFStrings writable. (See <rdar://problem/10657500>)
Mike Stump1eb44332009-09-09 15:08:12 +00002284 llvm::GlobalVariable *GV =
Bill Wendling1bf7a3f2012-01-10 08:46:39 +00002285 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
2286 Linkage, C, ".str");
Rafael Espindolab266a1f2011-01-17 16:31:00 +00002287 GV->setUnnamedAddr(true);
Ulrich Weigand6b203512013-05-06 16:23:57 +00002288 // Don't enforce the target's minimum global alignment, since the only use
2289 // of the string is via this class initializer.
Daniel Dunbara9668e02009-04-03 00:57:44 +00002290 if (isUTF16) {
Ken Dyck4da244c2010-01-26 18:46:23 +00002291 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
2292 GV->setAlignment(Align.getQuantity());
Daniel Dunbarf7e903d2011-04-12 23:30:52 +00002293 } else {
2294 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2295 GV->setAlignment(Align.getQuantity());
Daniel Dunbara9668e02009-04-03 00:57:44 +00002296 }
Bill Wendling84392d02012-03-30 00:26:17 +00002297
2298 // String.
Jay Foada5c04342011-07-21 14:31:17 +00002299 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Anders Carlsson5add6832009-08-16 05:55:31 +00002300
Bill Wendling84392d02012-03-30 00:26:17 +00002301 if (isUTF16)
2302 // Cast the UTF16 string to the correct type.
2303 Fields[2] = llvm::ConstantExpr::getBitCast(Fields[2], Int8PtrTy);
2304
Anders Carlssonc9e20912007-08-21 00:21:21 +00002305 // String length.
2306 Ty = getTypes().ConvertType(getContext().LongTy);
Anders Carlsson5add6832009-08-16 05:55:31 +00002307 Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
Mike Stump1eb44332009-09-09 15:08:12 +00002308
Anders Carlssonc9e20912007-08-21 00:21:21 +00002309 // The struct.
Owen Anderson08e25242009-07-27 22:29:56 +00002310 C = llvm::ConstantStruct::get(STy, Fields);
Mike Stump1eb44332009-09-09 15:08:12 +00002311 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2312 llvm::GlobalVariable::PrivateLinkage, C,
Chris Lattner95b851e2009-07-16 05:03:48 +00002313 "_unnamed_cfstring_");
John McCall64aa4b32013-04-16 22:48:15 +00002314 if (const char *Sect = getTarget().getCFStringSection())
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00002315 GV->setSection(Sect);
Daniel Dunbar1d552912009-07-23 22:52:48 +00002316 Entry.setValue(GV);
Mike Stump1eb44332009-09-09 15:08:12 +00002317
Anders Carlsson0c678292007-11-01 00:41:52 +00002318 return GV;
Anders Carlssonc9e20912007-08-21 00:21:21 +00002319}
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002320
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002321static RecordDecl *
2322CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK,
2323 DeclContext *DC, IdentifierInfo *Id) {
2324 SourceLocation Loc;
David Blaikie4e4d0842012-03-11 07:00:24 +00002325 if (Ctx.getLangOpts().CPlusPlus)
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002326 return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2327 else
2328 return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
2329}
2330
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00002331llvm::Constant *
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002332CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002333 unsigned StringLength = 0;
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002334 llvm::StringMapEntry<llvm::Constant*> &Entry =
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002335 GetConstantStringEntry(CFConstantStringMap, Literal, StringLength);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002336
2337 if (llvm::Constant *C = Entry.getValue())
2338 return C;
2339
Chris Lattner812234b2012-02-06 22:47:00 +00002340 llvm::Constant *Zero = llvm::Constant::getNullValue(Int32Ty);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002341 llvm::Constant *Zeros[] = { Zero, Zero };
Fariborz Jahanian428edb72013-04-16 15:25:39 +00002342 llvm::Value *V;
Fariborz Jahanianec951e02010-04-23 22:33:39 +00002343 // If we don't already have it, get _NSConstantStringClassReference.
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002344 if (!ConstantStringClassRef) {
David Blaikie4e4d0842012-03-11 07:00:24 +00002345 std::string StringClass(getLangOpts().ObjCConstantStringClass);
Chris Lattner2acc6e32011-07-18 04:24:23 +00002346 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002347 llvm::Constant *GV;
John McCall260611a2012-06-20 06:18:46 +00002348 if (LangOpts.ObjCRuntime.isNonFragile()) {
Fariborz Jahanian25dba5d2011-05-17 22:46:11 +00002349 std::string str =
2350 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
2351 : "OBJC_CLASS_$_" + StringClass;
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00002352 GV = getObjCRuntime().GetClassGlobal(str);
2353 // Make sure the result is of the correct type.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002354 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
Fariborz Jahanian428edb72013-04-16 15:25:39 +00002355 V = llvm::ConstantExpr::getBitCast(GV, PTy);
2356 ConstantStringClassRef = V;
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00002357 } else {
Fariborz Jahanian25dba5d2011-05-17 22:46:11 +00002358 std::string str =
2359 StringClass.empty() ? "_NSConstantStringClassReference"
2360 : "_" + StringClass + "ClassReference";
Chris Lattner2acc6e32011-07-18 04:24:23 +00002361 llvm::Type *PTy = llvm::ArrayType::get(Ty, 0);
Fariborz Jahanian25dba5d2011-05-17 22:46:11 +00002362 GV = CreateRuntimeVariable(PTy, str);
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00002363 // Decay array -> ptr
Fariborz Jahanian428edb72013-04-16 15:25:39 +00002364 V = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
2365 ConstantStringClassRef = V;
Fariborz Jahanian4c733072010-10-19 17:19:29 +00002366 }
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002367 }
Fariborz Jahanian428edb72013-04-16 15:25:39 +00002368 else
2369 V = ConstantStringClassRef;
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002370
2371 if (!NSConstantStringType) {
2372 // Construct the type for a constant NSString.
2373 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2374 Context.getTranslationUnitDecl(),
2375 &Context.Idents.get("__builtin_NSString"));
2376 D->startDefinition();
2377
2378 QualType FieldTypes[3];
2379
2380 // const int *isa;
2381 FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst());
2382 // const char *str;
2383 FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst());
2384 // unsigned int length;
2385 FieldTypes[2] = Context.UnsignedIntTy;
2386
2387 // Create fields
2388 for (unsigned i = 0; i < 3; ++i) {
2389 FieldDecl *Field = FieldDecl::Create(Context, D,
2390 SourceLocation(),
2391 SourceLocation(), 0,
2392 FieldTypes[i], /*TInfo=*/0,
2393 /*BitWidth=*/0,
2394 /*Mutable=*/false,
Richard Smithca523302012-06-10 03:12:00 +00002395 ICIS_NoInit);
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002396 Field->setAccess(AS_public);
2397 D->addDecl(Field);
2398 }
2399
2400 D->completeDefinition();
2401 QualType NSTy = Context.getTagDeclType(D);
2402 NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy));
2403 }
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002404
Benjamin Kramer1d236ab2011-10-15 12:20:02 +00002405 llvm::Constant *Fields[3];
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002406
2407 // Class pointer.
Fariborz Jahanian428edb72013-04-16 15:25:39 +00002408 Fields[0] = cast<llvm::ConstantExpr>(V);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002409
2410 // String pointer.
Chris Lattner94010692012-02-05 02:30:40 +00002411 llvm::Constant *C =
2412 llvm::ConstantDataArray::getString(VMContext, Entry.getKey());
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002413
2414 llvm::GlobalValue::LinkageTypes Linkage;
2415 bool isConstant;
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002416 Linkage = llvm::GlobalValue::PrivateLinkage;
David Blaikie4e4d0842012-03-11 07:00:24 +00002417 isConstant = !LangOpts.WritableStrings;
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002418
2419 llvm::GlobalVariable *GV =
2420 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
2421 ".str");
Rafael Espindola803d3072011-01-17 22:11:21 +00002422 GV->setUnnamedAddr(true);
Ulrich Weigand6b203512013-05-06 16:23:57 +00002423 // Don't enforce the target's minimum global alignment, since the only use
2424 // of the string is via this class initializer.
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00002425 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
2426 GV->setAlignment(Align.getQuantity());
Jay Foada5c04342011-07-21 14:31:17 +00002427 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002428
2429 // String length.
Chris Lattner2acc6e32011-07-18 04:24:23 +00002430 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002431 Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
2432
2433 // The struct.
Douglas Gregor45c4ea72011-08-09 15:54:21 +00002434 C = llvm::ConstantStruct::get(NSConstantStringType, Fields);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002435 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
2436 llvm::GlobalVariable::PrivateLinkage, C,
2437 "_unnamed_nsstring_");
2438 // FIXME. Fix section.
Fariborz Jahanianec951e02010-04-23 22:33:39 +00002439 if (const char *Sect =
John McCall260611a2012-06-20 06:18:46 +00002440 LangOpts.ObjCRuntime.isNonFragile()
John McCall64aa4b32013-04-16 22:48:15 +00002441 ? getTarget().getNSStringNonFragileABISection()
2442 : getTarget().getNSStringSection())
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00002443 GV->setSection(Sect);
2444 Entry.setValue(GV);
2445
2446 return GV;
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00002447}
2448
Douglas Gregor0815b572011-08-09 17:23:49 +00002449QualType CodeGenModule::getObjCFastEnumerationStateType() {
2450 if (ObjCFastEnumerationStateType.isNull()) {
2451 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
2452 Context.getTranslationUnitDecl(),
2453 &Context.Idents.get("__objcFastEnumerationState"));
2454 D->startDefinition();
2455
2456 QualType FieldTypes[] = {
2457 Context.UnsignedLongTy,
2458 Context.getPointerType(Context.getObjCIdType()),
2459 Context.getPointerType(Context.UnsignedLongTy),
2460 Context.getConstantArrayType(Context.UnsignedLongTy,
2461 llvm::APInt(32, 5), ArrayType::Normal, 0)
2462 };
2463
2464 for (size_t i = 0; i < 4; ++i) {
2465 FieldDecl *Field = FieldDecl::Create(Context,
2466 D,
2467 SourceLocation(),
2468 SourceLocation(), 0,
2469 FieldTypes[i], /*TInfo=*/0,
2470 /*BitWidth=*/0,
2471 /*Mutable=*/false,
Richard Smithca523302012-06-10 03:12:00 +00002472 ICIS_NoInit);
Douglas Gregor0815b572011-08-09 17:23:49 +00002473 Field->setAccess(AS_public);
2474 D->addDecl(Field);
2475 }
2476
2477 D->completeDefinition();
2478 ObjCFastEnumerationStateType = Context.getTagDeclType(D);
2479 }
2480
2481 return ObjCFastEnumerationStateType;
2482}
2483
Eli Friedman64f45a22011-11-01 02:23:42 +00002484llvm::Constant *
2485CodeGenModule::GetConstantArrayFromStringLiteral(const StringLiteral *E) {
2486 assert(!E->getType()->isPointerType() && "Strings are always arrays");
2487
2488 // Don't emit it as the address of the string, emit the string data itself
2489 // as an inline array.
Chris Lattner812234b2012-02-06 22:47:00 +00002490 if (E->getCharByteWidth() == 1) {
2491 SmallString<64> Str(E->getString());
2492
2493 // Resize the string to the right size, which is indicated by its type.
2494 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
2495 Str.resize(CAT->getSize().getZExtValue());
2496 return llvm::ConstantDataArray::getString(VMContext, Str, false);
2497 }
Chris Lattner94010692012-02-05 02:30:40 +00002498
2499 llvm::ArrayType *AType =
2500 cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
2501 llvm::Type *ElemTy = AType->getElementType();
2502 unsigned NumElements = AType->getNumElements();
Chris Lattnerd79ed432012-02-06 22:52:04 +00002503
2504 // Wide strings have either 2-byte or 4-byte elements.
2505 if (ElemTy->getPrimitiveSizeInBits() == 16) {
2506 SmallVector<uint16_t, 32> Elements;
2507 Elements.reserve(NumElements);
2508
2509 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2510 Elements.push_back(E->getCodeUnit(i));
2511 Elements.resize(NumElements);
2512 return llvm::ConstantDataArray::get(VMContext, Elements);
Chris Lattner94010692012-02-05 02:30:40 +00002513 }
2514
Chris Lattnerd79ed432012-02-06 22:52:04 +00002515 assert(ElemTy->getPrimitiveSizeInBits() == 32);
2516 SmallVector<uint32_t, 32> Elements;
2517 Elements.reserve(NumElements);
2518
2519 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
2520 Elements.push_back(E->getCodeUnit(i));
2521 Elements.resize(NumElements);
2522 return llvm::ConstantDataArray::get(VMContext, Elements);
Eli Friedman64f45a22011-11-01 02:23:42 +00002523}
2524
Daniel Dunbar61432932008-08-13 23:20:05 +00002525/// GetAddrOfConstantStringFromLiteral - Return a pointer to a
2526/// constant array for the given string literal.
2527llvm::Constant *
2528CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
Ulrich Weigand6b203512013-05-06 16:23:57 +00002529 CharUnits Align = getContext().getAlignOfGlobalVarInChars(S->getType());
Eli Friedman64f45a22011-11-01 02:23:42 +00002530 if (S->isAscii() || S->isUTF8()) {
Chris Lattner812234b2012-02-06 22:47:00 +00002531 SmallString<64> Str(S->getString());
2532
2533 // Resize the string to the right size, which is indicated by its type.
2534 const ConstantArrayType *CAT = Context.getAsConstantArrayType(S->getType());
2535 Str.resize(CAT->getSize().getZExtValue());
2536 return GetAddrOfConstantString(Str, /*GlobalName*/ 0, Align.getQuantity());
Eli Friedman7eb79c12009-11-16 05:55:46 +00002537 }
Eli Friedman64f45a22011-11-01 02:23:42 +00002538
Chris Lattner812234b2012-02-06 22:47:00 +00002539 // FIXME: the following does not memoize wide strings.
Eli Friedman64f45a22011-11-01 02:23:42 +00002540 llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
2541 llvm::GlobalVariable *GV =
2542 new llvm::GlobalVariable(getModule(),C->getType(),
David Blaikie4e4d0842012-03-11 07:00:24 +00002543 !LangOpts.WritableStrings,
Eli Friedman64f45a22011-11-01 02:23:42 +00002544 llvm::GlobalValue::PrivateLinkage,
2545 C,".str");
Seth Cantrell7d6a7c02012-01-18 12:11:32 +00002546
Eli Friedman64f45a22011-11-01 02:23:42 +00002547 GV->setAlignment(Align.getQuantity());
2548 GV->setUnnamedAddr(true);
Eli Friedman64f45a22011-11-01 02:23:42 +00002549 return GV;
Daniel Dunbar61432932008-08-13 23:20:05 +00002550}
2551
Chris Lattnereaf2bb82009-02-24 22:18:39 +00002552/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
2553/// array for the given ObjCEncodeExpr node.
2554llvm::Constant *
2555CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
2556 std::string Str;
2557 getContext().getObjCEncodingForType(E->getEncodedType(), Str);
Eli Friedmana210f352009-03-07 20:17:55 +00002558
2559 return GetAddrOfConstantCString(Str);
Chris Lattnereaf2bb82009-02-24 22:18:39 +00002560}
2561
2562
Chris Lattnera7ad98f2008-02-11 00:02:17 +00002563/// GenerateWritableString -- Creates storage for a string literal.
John McCalla5e19c62011-08-04 01:03:22 +00002564static llvm::GlobalVariable *GenerateStringLiteral(StringRef str,
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002565 bool constant,
Daniel Dunbar5fabf9d2008-10-17 21:56:50 +00002566 CodeGenModule &CGM,
John McCalla5e19c62011-08-04 01:03:22 +00002567 const char *GlobalName,
2568 unsigned Alignment) {
Daniel Dunbar61432932008-08-13 23:20:05 +00002569 // Create Constant for this string literal. Don't add a '\0'.
Owen Anderson0032b272009-08-13 21:57:51 +00002570 llvm::Constant *C =
Chris Lattner94010692012-02-05 02:30:40 +00002571 llvm::ConstantDataArray::getString(CGM.getLLVMContext(), str, false);
Mike Stump1eb44332009-09-09 15:08:12 +00002572
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002573 // Create a global variable for this string
Rafael Espindola1257bc62011-01-10 22:34:03 +00002574 llvm::GlobalVariable *GV =
2575 new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
2576 llvm::GlobalValue::PrivateLinkage,
2577 C, GlobalName);
John McCalla5e19c62011-08-04 01:03:22 +00002578 GV->setAlignment(Alignment);
Rafael Espindola1257bc62011-01-10 22:34:03 +00002579 GV->setUnnamedAddr(true);
2580 return GV;
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002581}
2582
Daniel Dunbar61432932008-08-13 23:20:05 +00002583/// GetAddrOfConstantString - Returns a pointer to a character array
2584/// containing the literal. This contents are exactly that of the
2585/// given string, i.e. it will not be null terminated automatically;
2586/// see GetAddrOfConstantCString. Note that whether the result is
2587/// actually a pointer to an LLVM constant depends on
2588/// Feature.WriteableStrings.
2589///
2590/// The result has pointer to array type.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002591llvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str,
John McCalla5e19c62011-08-04 01:03:22 +00002592 const char *GlobalName,
2593 unsigned Alignment) {
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00002594 // Get the default prefix if a name wasn't specified.
2595 if (!GlobalName)
Chris Lattner95b851e2009-07-16 05:03:48 +00002596 GlobalName = ".str";
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00002597
Ulrich Weigand6b203512013-05-06 16:23:57 +00002598 if (Alignment == 0)
2599 Alignment = getContext().getAlignOfGlobalVarInChars(getContext().CharTy)
2600 .getQuantity();
2601
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00002602 // Don't share any string literals if strings aren't constant.
David Blaikie4e4d0842012-03-11 07:00:24 +00002603 if (LangOpts.WritableStrings)
John McCalla5e19c62011-08-04 01:03:22 +00002604 return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment);
Mike Stump1eb44332009-09-09 15:08:12 +00002605
John McCalla5e19c62011-08-04 01:03:22 +00002606 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
Benjamin Kramer9de43422011-03-05 13:45:23 +00002607 ConstantStringMap.GetOrCreateValue(Str);
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002608
John McCalla5e19c62011-08-04 01:03:22 +00002609 if (llvm::GlobalVariable *GV = Entry.getValue()) {
2610 if (Alignment > GV->getAlignment()) {
2611 GV->setAlignment(Alignment);
2612 }
2613 return GV;
2614 }
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002615
2616 // Create a global variable for this.
Chris Lattner812234b2012-02-06 22:47:00 +00002617 llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName,
2618 Alignment);
John McCalla5e19c62011-08-04 01:03:22 +00002619 Entry.setValue(GV);
2620 return GV;
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002621}
Daniel Dunbar61432932008-08-13 23:20:05 +00002622
2623/// GetAddrOfConstantCString - Returns a pointer to a character
Benjamin Kramer9de43422011-03-05 13:45:23 +00002624/// array containing the literal and a terminating '\0'
Daniel Dunbar61432932008-08-13 23:20:05 +00002625/// character. The result has pointer to array type.
Benjamin Kramer9de43422011-03-05 13:45:23 +00002626llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str,
John McCalla5e19c62011-08-04 01:03:22 +00002627 const char *GlobalName,
2628 unsigned Alignment) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00002629 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
John McCalla5e19c62011-08-04 01:03:22 +00002630 return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment);
Daniel Dunbar61432932008-08-13 23:20:05 +00002631}
Daniel Dunbar41071de2008-08-15 23:26:23 +00002632
Richard Smith211c8dd2013-06-05 00:46:14 +00002633llvm::Constant *CodeGenModule::GetAddrOfGlobalTemporary(
Richard Smith3282b842013-06-14 03:07:01 +00002634 const MaterializeTemporaryExpr *E, const Expr *Init) {
Richard Smith211c8dd2013-06-05 00:46:14 +00002635 assert((E->getStorageDuration() == SD_Static ||
2636 E->getStorageDuration() == SD_Thread) && "not a global temporary");
2637 const VarDecl *VD = cast<VarDecl>(E->getExtendingDecl());
2638
2639 // If we're not materializing a subobject of the temporary, keep the
2640 // cv-qualifiers from the type of the MaterializeTemporaryExpr.
Richard Smith3282b842013-06-14 03:07:01 +00002641 QualType MaterializedType = Init->getType();
2642 if (Init == E->GetTemporaryExpr())
2643 MaterializedType = E->getType();
Richard Smith211c8dd2013-06-05 00:46:14 +00002644
2645 llvm::Constant *&Slot = MaterializedGlobalTemporaryMap[E];
2646 if (Slot)
2647 return Slot;
2648
2649 // FIXME: If an externally-visible declaration extends multiple temporaries,
2650 // we need to give each temporary the same name in every translation unit (and
2651 // we also need to make the temporaries externally-visible).
2652 SmallString<256> Name;
2653 llvm::raw_svector_ostream Out(Name);
2654 getCXXABI().getMangleContext().mangleReferenceTemporary(VD, Out);
2655 Out.flush();
2656
Richard Smith211c8dd2013-06-05 00:46:14 +00002657 APValue *Value = 0;
2658 if (E->getStorageDuration() == SD_Static) {
Richard Smith3282b842013-06-14 03:07:01 +00002659 // We might have a cached constant initializer for this temporary. Note
2660 // that this might have a different value from the value computed by
2661 // evaluating the initializer if the surrounding constant expression
2662 // modifies the temporary.
Richard Smith211c8dd2013-06-05 00:46:14 +00002663 Value = getContext().getMaterializedTemporaryValue(E, false);
2664 if (Value && Value->isUninit())
2665 Value = 0;
2666 }
2667
Richard Smith3282b842013-06-14 03:07:01 +00002668 // Try evaluating it now, it might have a constant initializer.
2669 Expr::EvalResult EvalResult;
2670 if (!Value && Init->EvaluateAsRValue(EvalResult, getContext()) &&
2671 !EvalResult.hasSideEffects())
2672 Value = &EvalResult.Val;
2673
2674 llvm::Constant *InitialValue = 0;
2675 bool Constant = false;
2676 llvm::Type *Type;
Richard Smith211c8dd2013-06-05 00:46:14 +00002677 if (Value) {
2678 // The temporary has a constant initializer, use it.
Richard Smith3282b842013-06-14 03:07:01 +00002679 InitialValue = EmitConstantValue(*Value, MaterializedType, 0);
2680 Constant = isTypeConstant(MaterializedType, /*ExcludeCtor*/Value);
2681 Type = InitialValue->getType();
Richard Smith211c8dd2013-06-05 00:46:14 +00002682 } else {
Richard Smith3282b842013-06-14 03:07:01 +00002683 // No initializer, the initialization will be provided when we
Richard Smith211c8dd2013-06-05 00:46:14 +00002684 // initialize the declaration which performed lifetime extension.
Richard Smith3282b842013-06-14 03:07:01 +00002685 Type = getTypes().ConvertTypeForMem(MaterializedType);
Richard Smith211c8dd2013-06-05 00:46:14 +00002686 }
2687
2688 // Create a global variable for this lifetime-extended temporary.
2689 llvm::GlobalVariable *GV =
Richard Smith3282b842013-06-14 03:07:01 +00002690 new llvm::GlobalVariable(getModule(), Type, Constant,
2691 llvm::GlobalValue::PrivateLinkage,
2692 InitialValue, Name.c_str());
Richard Smith211c8dd2013-06-05 00:46:14 +00002693 GV->setAlignment(
Richard Smith3282b842013-06-14 03:07:01 +00002694 getContext().getTypeAlignInChars(MaterializedType).getQuantity());
Richard Smith211c8dd2013-06-05 00:46:14 +00002695 if (VD->getTLSKind())
2696 setTLSMode(GV, *VD);
2697 Slot = GV;
2698 return GV;
2699}
2700
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002701/// EmitObjCPropertyImplementations - Emit information for synthesized
2702/// properties for an implementation.
Mike Stump1eb44332009-09-09 15:08:12 +00002703void CodeGenModule::EmitObjCPropertyImplementations(const
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002704 ObjCImplementationDecl *D) {
Mike Stump1eb44332009-09-09 15:08:12 +00002705 for (ObjCImplementationDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002706 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
David Blaikie581deb32012-06-06 20:45:41 +00002707 ObjCPropertyImplDecl *PID = *i;
Mike Stump1eb44332009-09-09 15:08:12 +00002708
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002709 // Dynamic is just for type-checking.
2710 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
2711 ObjCPropertyDecl *PD = PID->getPropertyDecl();
2712
2713 // Determine which methods need to be implemented, some may have
Jordan Rose1e4691b2012-10-10 16:42:25 +00002714 // been overridden. Note that ::isPropertyAccessor is not the method
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002715 // we want, that just indicates if the decl came from a
2716 // property. What we want to know is if the method is defined in
2717 // this implementation.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002718 if (!D->getInstanceMethod(PD->getGetterName()))
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00002719 CodeGenFunction(*this).GenerateObjCGetter(
2720 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002721 if (!PD->isReadOnly() &&
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002722 !D->getInstanceMethod(PD->getSetterName()))
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00002723 CodeGenFunction(*this).GenerateObjCSetter(
2724 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002725 }
2726 }
2727}
2728
John McCalle81ac692011-03-22 07:05:39 +00002729static bool needsDestructMethod(ObjCImplementationDecl *impl) {
Jordy Rosedb8264e2011-07-22 02:08:32 +00002730 const ObjCInterfaceDecl *iface = impl->getClassInterface();
2731 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
John McCalle81ac692011-03-22 07:05:39 +00002732 ivar; ivar = ivar->getNextIvar())
2733 if (ivar->getType().isDestructedType())
2734 return true;
2735
2736 return false;
2737}
2738
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002739/// EmitObjCIvarInitializations - Emit information for ivar initialization
2740/// for an implementation.
2741void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
John McCalle81ac692011-03-22 07:05:39 +00002742 // We might need a .cxx_destruct even if we don't have any ivar initializers.
2743 if (needsDestructMethod(D)) {
2744 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
2745 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
2746 ObjCMethodDecl *DTORMethod =
2747 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002748 cxxSelector, getContext().VoidTy, 0, D,
2749 /*isInstance=*/true, /*isVariadic=*/false,
Jordan Rose1e4691b2012-10-10 16:42:25 +00002750 /*isPropertyAccessor=*/true, /*isImplicitlyDeclared=*/true,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002751 /*isDefined=*/false, ObjCMethodDecl::Required);
John McCalle81ac692011-03-22 07:05:39 +00002752 D->addInstanceMethod(DTORMethod);
2753 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
John McCallb03527a2012-10-17 04:53:31 +00002754 D->setHasDestructors(true);
John McCalle81ac692011-03-22 07:05:39 +00002755 }
2756
2757 // If the implementation doesn't have any ivar initializers, we don't need
2758 // a .cxx_construct.
David Chisnall827bbcc2011-03-17 14:19:08 +00002759 if (D->getNumIvarInitializers() == 0)
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002760 return;
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002761
John McCalle81ac692011-03-22 07:05:39 +00002762 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
2763 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002764 // The constructor returns 'self'.
2765 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
2766 D->getLocation(),
Argyrios Kyrtzidis11d77162011-10-03 06:36:36 +00002767 D->getLocation(),
Argyrios Kyrtzidis11d77162011-10-03 06:36:36 +00002768 cxxSelector,
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002769 getContext().getObjCIdType(), 0,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002770 D, /*isInstance=*/true,
2771 /*isVariadic=*/false,
Jordan Rose1e4691b2012-10-10 16:42:25 +00002772 /*isPropertyAccessor=*/true,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002773 /*isImplicitlyDeclared=*/true,
2774 /*isDefined=*/false,
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002775 ObjCMethodDecl::Required);
2776 D->addInstanceMethod(CTORMethod);
2777 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
John McCallb03527a2012-10-17 04:53:31 +00002778 D->setHasNonZeroConstructors(true);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002779}
2780
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002781/// EmitNamespace - Emit all declarations in a namespace.
Anders Carlsson984e0682009-04-01 00:58:25 +00002782void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002783 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
Anders Carlsson984e0682009-04-01 00:58:25 +00002784 I != E; ++I)
2785 EmitTopLevelDecl(*I);
2786}
2787
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002788// EmitLinkageSpec - Emit all declarations in a linkage spec.
2789void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
Eli Friedmanf976be82009-08-01 20:48:04 +00002790 if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
2791 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002792 ErrorUnsupported(LSD, "linkage spec");
2793 return;
2794 }
2795
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002796 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
Fariborz Jahanianc1868e52012-10-26 20:22:11 +00002797 I != E; ++I) {
Fariborz Jahanian107dae42012-10-26 22:20:25 +00002798 // Meta-data for ObjC class includes references to implemented methods.
2799 // Generate class's method definitions first.
Fariborz Jahanianc1868e52012-10-26 20:22:11 +00002800 if (ObjCImplDecl *OID = dyn_cast<ObjCImplDecl>(*I)) {
2801 for (ObjCContainerDecl::method_iterator M = OID->meth_begin(),
2802 MEnd = OID->meth_end();
2803 M != MEnd; ++M)
2804 EmitTopLevelDecl(*M);
2805 }
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002806 EmitTopLevelDecl(*I);
Fariborz Jahanianc1868e52012-10-26 20:22:11 +00002807 }
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002808}
2809
Daniel Dunbar41071de2008-08-15 23:26:23 +00002810/// EmitTopLevelDecl - Emit code for a single top level declaration.
2811void CodeGenModule::EmitTopLevelDecl(Decl *D) {
2812 // If an error has occurred, stop code generation, but continue
2813 // parsing and semantic analysis (to ensure all warnings and errors
2814 // are emitted).
2815 if (Diags.hasErrorOccurred())
2816 return;
2817
Douglas Gregor16e8be22009-06-29 17:30:29 +00002818 // Ignore dependent declarations.
2819 if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
2820 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002821
Daniel Dunbar41071de2008-08-15 23:26:23 +00002822 switch (D->getKind()) {
Anders Carlsson293361a2009-08-25 13:14:46 +00002823 case Decl::CXXConversion:
Anders Carlsson2b77ba82009-04-04 20:47:02 +00002824 case Decl::CXXMethod:
Daniel Dunbar41071de2008-08-15 23:26:23 +00002825 case Decl::Function:
Douglas Gregor16e8be22009-06-29 17:30:29 +00002826 // Skip function templates
Francois Pichet8387e2a2011-04-22 22:18:13 +00002827 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2828 cast<FunctionDecl>(D)->isLateTemplateParsed())
Douglas Gregor16e8be22009-06-29 17:30:29 +00002829 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002830
Anders Carlsson555b4bb2009-09-10 23:43:36 +00002831 EmitGlobal(cast<FunctionDecl>(D));
2832 break;
Larisse Voufoef4579c2013-08-06 01:03:05 +00002833
Daniel Dunbar41071de2008-08-15 23:26:23 +00002834 case Decl::Var:
Larisse Voufoef4579c2013-08-06 01:03:05 +00002835 // Skip variable templates
2836 if (cast<VarDecl>(D)->getDescribedVarTemplate())
2837 return;
2838 case Decl::VarTemplateSpecialization:
Anders Carlsson555b4bb2009-09-10 23:43:36 +00002839 EmitGlobal(cast<VarDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002840 break;
2841
John McCall26fbc722011-04-12 01:01:22 +00002842 // Indirect fields from global anonymous structs and unions can be
2843 // ignored; only the actual variable requires IR gen support.
2844 case Decl::IndirectField:
2845 break;
2846
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002847 // C++ Decls
Daniel Dunbar41071de2008-08-15 23:26:23 +00002848 case Decl::Namespace:
Anders Carlsson984e0682009-04-01 00:58:25 +00002849 EmitNamespace(cast<NamespaceDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002850 break;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002851 // No code generation needed.
John McCall9d0c6612009-11-17 09:33:40 +00002852 case Decl::UsingShadow:
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002853 case Decl::Using:
Douglas Gregor127102b2009-06-29 20:59:39 +00002854 case Decl::ClassTemplate:
Larisse Voufoef4579c2013-08-06 01:03:05 +00002855 case Decl::VarTemplate:
2856 case Decl::VarTemplatePartialSpecialization:
Douglas Gregor127102b2009-06-29 20:59:39 +00002857 case Decl::FunctionTemplate:
Richard Smith3e4c6c42011-05-05 21:57:07 +00002858 case Decl::TypeAliasTemplate:
Douglas Gregor6a576ab2011-06-05 05:04:23 +00002859 case Decl::Block:
Michael Han684aa732013-02-22 17:15:32 +00002860 case Decl::Empty:
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002861 break;
David Blaikiefc46ebc2013-05-20 22:50:41 +00002862 case Decl::NamespaceAlias:
2863 if (CGDebugInfo *DI = getModuleDebugInfo())
2864 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D));
2865 return;
David Blaikie1601a4a2013-04-26 05:41:06 +00002866 case Decl::UsingDirective: // using namespace X; [C++]
2867 if (CGDebugInfo *DI = getModuleDebugInfo())
2868 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D));
2869 return;
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002870 case Decl::CXXConstructor:
Anders Carlsson1fe598c2009-11-24 05:16:24 +00002871 // Skip function templates
Francois Pichet8387e2a2011-04-22 22:18:13 +00002872 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2873 cast<FunctionDecl>(D)->isLateTemplateParsed())
Anders Carlsson1fe598c2009-11-24 05:16:24 +00002874 return;
2875
Timur Iskhodzhanovbb1b7972013-08-04 17:30:04 +00002876 getCXXABI().EmitCXXConstructors(cast<CXXConstructorDecl>(D));
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002877 break;
Anders Carlsson27ae5362009-04-17 01:58:57 +00002878 case Decl::CXXDestructor:
Francois Pichet8387e2a2011-04-22 22:18:13 +00002879 if (cast<FunctionDecl>(D)->isLateTemplateParsed())
2880 return;
Reid Klecknera4130ba2013-07-22 13:51:44 +00002881 getCXXABI().EmitCXXDestructors(cast<CXXDestructorDecl>(D));
Anders Carlsson27ae5362009-04-17 01:58:57 +00002882 break;
Anders Carlsson36674d22009-06-11 21:22:55 +00002883
2884 case Decl::StaticAssert:
2885 // Nothing to do.
2886 break;
2887
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002888 // Objective-C Decls
Mike Stump1eb44332009-09-09 15:08:12 +00002889
Fariborz Jahanian38e24c72009-03-18 22:33:24 +00002890 // Forward declarations, no (immediate) code generation.
Chris Lattner285d0db2009-04-01 02:36:43 +00002891 case Decl::ObjCInterface:
Eric Christopherffb0c3a2012-07-19 22:22:55 +00002892 case Decl::ObjCCategory:
Chris Lattner285d0db2009-04-01 02:36:43 +00002893 break;
2894
Douglas Gregorbd9482d2012-01-01 21:23:57 +00002895 case Decl::ObjCProtocol: {
2896 ObjCProtocolDecl *Proto = cast<ObjCProtocolDecl>(D);
2897 if (Proto->isThisDeclarationADefinition())
2898 ObjCRuntime->GenerateProtocol(Proto);
Daniel Dunbar41071de2008-08-15 23:26:23 +00002899 break;
Douglas Gregorbd9482d2012-01-01 21:23:57 +00002900 }
2901
Daniel Dunbar41071de2008-08-15 23:26:23 +00002902 case Decl::ObjCCategoryImpl:
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002903 // Categories have properties but don't support synthesize so we
2904 // can ignore them here.
Peter Collingbournee9265232011-07-27 20:29:46 +00002905 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002906 break;
2907
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002908 case Decl::ObjCImplementation: {
2909 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
2910 EmitObjCPropertyImplementations(OMD);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002911 EmitObjCIvarInitializations(OMD);
Peter Collingbournee9265232011-07-27 20:29:46 +00002912 ObjCRuntime->GenerateClass(OMD);
Eric Christopherbe6c6862012-04-11 05:56:05 +00002913 // Emit global variable debug information.
2914 if (CGDebugInfo *DI = getModuleDebugInfo())
Alexey Samsonov96a66392012-12-03 18:28:12 +00002915 if (getCodeGenOpts().getDebugInfo() >= CodeGenOptions::LimitedDebugInfo)
2916 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
2917 OMD->getClassInterface()), OMD->getLocation());
Daniel Dunbar41071de2008-08-15 23:26:23 +00002918 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002919 }
Daniel Dunbar41071de2008-08-15 23:26:23 +00002920 case Decl::ObjCMethod: {
2921 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
2922 // If this is not a prototype, emit the body.
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +00002923 if (OMD->getBody())
Daniel Dunbar41071de2008-08-15 23:26:23 +00002924 CodeGenFunction(*this).GenerateObjCMethod(OMD);
2925 break;
2926 }
Mike Stump1eb44332009-09-09 15:08:12 +00002927 case Decl::ObjCCompatibleAlias:
David Chisnall29254f42012-01-31 18:59:20 +00002928 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002929 break;
2930
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002931 case Decl::LinkageSpec:
2932 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002933 break;
Daniel Dunbar41071de2008-08-15 23:26:23 +00002934
2935 case Decl::FileScopeAsm: {
2936 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
Chris Lattner5f9e2722011-07-23 10:55:15 +00002937 StringRef AsmString = AD->getAsmString()->getString();
Mike Stump1eb44332009-09-09 15:08:12 +00002938
Daniel Dunbar41071de2008-08-15 23:26:23 +00002939 const std::string &S = getModule().getModuleInlineAsm();
2940 if (S.empty())
2941 getModule().setModuleInlineAsm(AsmString);
Joerg Sonnenberger8ce9cca2012-08-10 10:57:52 +00002942 else if (S.end()[-1] == '\n')
Chris Lattner9f5bff02011-07-23 20:04:25 +00002943 getModule().setModuleInlineAsm(S + AsmString.str());
Daniel Dunbar41071de2008-08-15 23:26:23 +00002944 else
Benjamin Kramer8d042582009-12-11 13:33:18 +00002945 getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
Daniel Dunbar41071de2008-08-15 23:26:23 +00002946 break;
2947 }
Mike Stump1eb44332009-09-09 15:08:12 +00002948
Douglas Gregorb6cbe512013-01-14 17:21:00 +00002949 case Decl::Import: {
2950 ImportDecl *Import = cast<ImportDecl>(D);
2951
2952 // Ignore import declarations that come from imported modules.
2953 if (clang::Module *Owner = Import->getOwningModule()) {
2954 if (getLangOpts().CurrentModule.empty() ||
2955 Owner->getTopLevelModule()->Name == getLangOpts().CurrentModule)
2956 break;
2957 }
2958
Douglas Gregor858afb32013-01-14 20:53:57 +00002959 ImportedModules.insert(Import->getImportedModule());
Douglas Gregorb6cbe512013-01-14 17:21:00 +00002960 break;
2961 }
2962
Mike Stump1eb44332009-09-09 15:08:12 +00002963 default:
Mike Stumpf5408fe2009-05-16 07:57:57 +00002964 // Make sure we handled everything we should, every other kind is a
2965 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
2966 // function. Need to recode Decl::Kind to do that easily.
Daniel Dunbar41071de2008-08-15 23:26:23 +00002967 assert(isa<TypeDecl>(D) && "Unsupported decl kind");
2968 }
2969}
John McCall744016d2010-07-06 23:57:41 +00002970
2971/// Turns the given pointer into a constant.
2972static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
2973 const void *Ptr) {
2974 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
Chris Lattner2acc6e32011-07-18 04:24:23 +00002975 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
John McCall744016d2010-07-06 23:57:41 +00002976 return llvm::ConstantInt::get(i64, PtrInt);
2977}
2978
2979static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
2980 llvm::NamedMDNode *&GlobalMetadata,
2981 GlobalDecl D,
2982 llvm::GlobalValue *Addr) {
2983 if (!GlobalMetadata)
2984 GlobalMetadata =
2985 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
2986
2987 // TODO: should we report variant information for ctors/dtors?
2988 llvm::Value *Ops[] = {
2989 Addr,
2990 GetPointerConstant(CGM.getLLVMContext(), D.getDecl())
2991 };
Jay Foad6f141652011-04-21 19:59:12 +00002992 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
John McCall744016d2010-07-06 23:57:41 +00002993}
2994
Richard Smith00249372013-04-06 05:00:46 +00002995/// For each function which is declared within an extern "C" region and marked
2996/// as 'used', but has internal linkage, create an alias from the unmangled
2997/// name to the mangled name if possible. People expect to be able to refer
2998/// to such functions with an unmangled name from inline assembly within the
2999/// same translation unit.
3000void CodeGenModule::EmitStaticExternCAliases() {
Richard Smith84083b72013-04-13 01:28:18 +00003001 for (StaticExternCMap::iterator I = StaticExternCValues.begin(),
3002 E = StaticExternCValues.end();
3003 I != E; ++I) {
3004 IdentifierInfo *Name = I->first;
3005 llvm::GlobalValue *Val = I->second;
Richard Smith67972042013-04-06 07:07:44 +00003006 if (Val && !getModule().getNamedValue(Name->getName()))
3007 AddUsedGlobal(new llvm::GlobalAlias(Val->getType(), Val->getLinkage(),
3008 Name->getName(), Val, &getModule()));
3009 }
Richard Smith00249372013-04-06 05:00:46 +00003010}
3011
John McCall744016d2010-07-06 23:57:41 +00003012/// Emits metadata nodes associating all the global values in the
3013/// current module with the Decls they came from. This is useful for
3014/// projects using IR gen as a subroutine.
3015///
3016/// Since there's currently no way to associate an MDNode directly
3017/// with an llvm::GlobalValue, we create a global named metadata
3018/// with the name 'clang.global.decl.ptrs'.
3019void CodeGenModule::EmitDeclMetadata() {
3020 llvm::NamedMDNode *GlobalMetadata = 0;
3021
3022 // StaticLocalDeclMap
Chris Lattner5f9e2722011-07-23 10:55:15 +00003023 for (llvm::DenseMap<GlobalDecl,StringRef>::iterator
John McCall744016d2010-07-06 23:57:41 +00003024 I = MangledDeclNames.begin(), E = MangledDeclNames.end();
3025 I != E; ++I) {
3026 llvm::GlobalValue *Addr = getModule().getNamedValue(I->second);
3027 EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr);
3028 }
3029}
3030
3031/// Emits metadata nodes for all the local variables in the current
3032/// function.
3033void CodeGenFunction::EmitDeclMetadata() {
3034 if (LocalDeclMap.empty()) return;
3035
3036 llvm::LLVMContext &Context = getLLVMContext();
3037
3038 // Find the unique metadata ID for this name.
3039 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
3040
3041 llvm::NamedMDNode *GlobalMetadata = 0;
3042
3043 for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator
3044 I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) {
3045 const Decl *D = I->first;
3046 llvm::Value *Addr = I->second;
3047
3048 if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
3049 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
Jay Foad6f141652011-04-21 19:59:12 +00003050 Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr));
John McCall744016d2010-07-06 23:57:41 +00003051 } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
3052 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
3053 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
3054 }
3055 }
3056}
Daniel Dunbar673431a2010-07-16 00:00:15 +00003057
Nick Lewycky3dc05412011-05-05 00:08:20 +00003058void CodeGenModule::EmitCoverageFile() {
3059 if (!getCodeGenOpts().CoverageFile.empty()) {
Nick Lewycky5ea4f442011-05-04 20:46:58 +00003060 if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) {
3061 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
3062 llvm::LLVMContext &Ctx = TheModule.getContext();
Nick Lewycky3dc05412011-05-05 00:08:20 +00003063 llvm::MDString *CoverageFile =
3064 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile);
Nick Lewycky5ea4f442011-05-04 20:46:58 +00003065 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
3066 llvm::MDNode *CU = CUNode->getOperand(i);
Nick Lewycky3dc05412011-05-05 00:08:20 +00003067 llvm::Value *node[] = { CoverageFile, CU };
Nick Lewycky5ea4f442011-05-04 20:46:58 +00003068 llvm::MDNode *N = llvm::MDNode::get(Ctx, node);
3069 GCov->addOperand(N);
3070 }
3071 }
3072 }
3073}
Nico Weberc5f80462012-10-11 10:13:44 +00003074
3075llvm::Constant *CodeGenModule::EmitUuidofInitializer(StringRef Uuid,
3076 QualType GuidType) {
3077 // Sema has checked that all uuid strings are of the form
3078 // "12345678-1234-1234-1234-1234567890ab".
3079 assert(Uuid.size() == 36);
3080 const char *Uuidstr = Uuid.data();
3081 for (int i = 0; i < 36; ++i) {
3082 if (i == 8 || i == 13 || i == 18 || i == 23) assert(Uuidstr[i] == '-');
Jordan Rose3f6f51e2013-02-08 22:30:41 +00003083 else assert(isHexDigit(Uuidstr[i]));
Nico Weberc5f80462012-10-11 10:13:44 +00003084 }
3085
3086 llvm::APInt Field0(32, StringRef(Uuidstr , 8), 16);
3087 llvm::APInt Field1(16, StringRef(Uuidstr + 9, 4), 16);
3088 llvm::APInt Field2(16, StringRef(Uuidstr + 14, 4), 16);
Nico Weber193646f2012-10-17 00:34:34 +00003089 static const int Field3ValueOffsets[] = { 19, 21, 24, 26, 28, 30, 32, 34 };
Nico Weberc5f80462012-10-11 10:13:44 +00003090
3091 APValue InitStruct(APValue::UninitStruct(), /*NumBases=*/0, /*NumFields=*/4);
3092 InitStruct.getStructField(0) = APValue(llvm::APSInt(Field0));
3093 InitStruct.getStructField(1) = APValue(llvm::APSInt(Field1));
3094 InitStruct.getStructField(2) = APValue(llvm::APSInt(Field2));
3095 APValue& Arr = InitStruct.getStructField(3);
3096 Arr = APValue(APValue::UninitArray(), 8, 8);
3097 for (int t = 0; t < 8; ++t)
Nico Weber43085812012-10-13 21:56:05 +00003098 Arr.getArrayInitializedElt(t) = APValue(llvm::APSInt(
3099 llvm::APInt(8, StringRef(Uuidstr + Field3ValueOffsets[t], 2), 16)));
Nico Weberc5f80462012-10-11 10:13:44 +00003100
3101 return EmitConstantValue(InitStruct, GuidType);
3102}