blob: 67757a22c5fcb98ec36860f9ec8376eeb67a7ce9 [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"
Chris Lattnerbd360642009-03-26 05:00:52 +000015#include "CGDebugInfo.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000016#include "CodeGenFunction.h"
Dan Gohman3d5aff52010-10-14 23:06:10 +000017#include "CodeGenTBAA.h"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000018#include "CGCall.h"
John McCall4c40d982010-08-31 07:33:07 +000019#include "CGCXXABI.h"
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +000020#include "CGObjCRuntime.h"
Anton Korobeynikov82d0a412010-01-10 12:58:08 +000021#include "TargetInfo.h"
Chandler Carruth06057ce2010-06-15 23:19:56 +000022#include "clang/Frontend/CodeGenOptions.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000023#include "clang/AST/ASTContext.h"
Ken Dyck687cc4a2010-01-26 13:48:07 +000024#include "clang/AST/CharUnits.h"
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000025#include "clang/AST/DeclObjC.h"
Chris Lattner21ef7ae2008-11-04 16:51:42 +000026#include "clang/AST/DeclCXX.h"
Douglas Gregoraf896892010-06-21 18:41:26 +000027#include "clang/AST/DeclTemplate.h"
Peter Collingbourne14110472011-01-13 18:57:25 +000028#include "clang/AST/Mangle.h"
Anders Carlsson1a5e0d72009-11-30 23:41:22 +000029#include "clang/AST/RecordLayout.h"
Chris Lattner1b63e4f2009-06-14 01:54:56 +000030#include "clang/Basic/Builtins.h"
Chris Lattner2c8569d2007-12-02 07:19:18 +000031#include "clang/Basic/Diagnostic.h"
Nate Begeman8bd4afe2008-04-19 04:17:09 +000032#include "clang/Basic/SourceManager.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000033#include "clang/Basic/TargetInfo.h"
Steve Naroffe9b7d8a2009-04-01 15:50:34 +000034#include "clang/Basic/ConvertUTF.h"
Nate Begemanec9426c2008-03-09 03:09:36 +000035#include "llvm/CallingConv.h"
Chris Lattnerbef20ac2007-08-31 04:31:45 +000036#include "llvm/Module.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000037#include "llvm/Intrinsics.h"
Chris Lattnerd5b89022009-12-28 21:44:41 +000038#include "llvm/LLVMContext.h"
John McCall6374c332010-03-06 00:35:14 +000039#include "llvm/ADT/Triple.h"
Rafael Espindolac4850c22011-02-10 23:59:36 +000040#include "llvm/Target/Mangler.h"
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000041#include "llvm/Target/TargetData.h"
Gabor Greif6ba728d2010-04-10 02:56:12 +000042#include "llvm/Support/CallSite.h"
Chris Lattner78f7ece2009-11-07 09:22:46 +000043#include "llvm/Support/ErrorHandling.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000044using namespace clang;
45using namespace CodeGen;
46
Julien Lerouge77f68bb2011-09-09 22:41:49 +000047static const char AnnotationSection[] = "llvm.metadata";
48
John McCallf16aa102010-08-22 21:01:12 +000049static CGCXXABI &createCXXABI(CodeGenModule &CGM) {
Douglas Gregorbcfd1f52011-09-02 00:18:52 +000050 switch (CGM.getContext().getTargetInfo().getCXXABI()) {
John McCallf16aa102010-08-22 21:01:12 +000051 case CXXABI_ARM: return *CreateARMCXXABI(CGM);
52 case CXXABI_Itanium: return *CreateItaniumCXXABI(CGM);
53 case CXXABI_Microsoft: return *CreateMicrosoftCXXABI(CGM);
54 }
55
56 llvm_unreachable("invalid C++ ABI kind");
57 return *CreateItaniumCXXABI(CGM);
58}
59
Reid Spencer5f016e22007-07-11 17:01:13 +000060
Chandler Carruth2811ccf2009-11-12 17:24:48 +000061CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
John McCall468ec6c2010-03-04 04:29:44 +000062 llvm::Module &M, const llvm::TargetData &TD,
63 Diagnostic &diags)
John McCalld16c2cf2011-02-08 08:22:06 +000064 : Context(C), Features(C.getLangOptions()), CodeGenOpts(CGO), TheModule(M),
John McCall468ec6c2010-03-04 04:29:44 +000065 TheTargetData(TD), TheTargetCodeGenInfo(0), Diags(diags),
John McCallf16aa102010-08-22 21:01:12 +000066 ABI(createCXXABI(*this)),
Daniel Dunbar08d47922011-06-21 18:54:39 +000067 Types(C, M, TD, getTargetCodeGenInfo().getABIInfo(), ABI, CGO),
Dan Gohman3d5aff52010-10-14 23:06:10 +000068 TBAA(0),
Peter Collingbournee9265232011-07-27 20:29:46 +000069 VTables(*this), ObjCRuntime(0), DebugInfo(0), ARCData(0), RRData(0),
Fariborz Jahanian4c733072010-10-19 17:19:29 +000070 CFConstantStringClassRef(0), ConstantStringClassRef(0),
Douglas Gregor45c4ea72011-08-09 15:54:21 +000071 NSConstantStringType(0),
Daniel Dunbar673431a2010-07-16 00:00:15 +000072 VMContext(M.getContext()),
73 NSConcreteGlobalBlock(0), NSConcreteStackBlock(0),
John McCalld16c2cf2011-02-08 08:22:06 +000074 BlockObjectAssign(0), BlockObjectDispose(0),
75 BlockDescriptorType(0), GenericBlockLiteralType(0) {
David Chisnall60be6072011-03-22 21:21:24 +000076 if (Features.ObjC1)
77 createObjCRuntime();
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +000078
Dan Gohman3d5aff52010-10-14 23:06:10 +000079 // Enable TBAA unless it's suppressed.
80 if (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0)
Dan Gohman0b5c4fc2010-10-15 20:23:12 +000081 TBAA = new CodeGenTBAA(Context, VMContext, getLangOptions(),
82 ABI.getMangleContext());
Dan Gohman3d5aff52010-10-14 23:06:10 +000083
Nick Lewyckye8ba8d72011-04-21 23:44:07 +000084 // If debug info or coverage generation is enabled, create the CGDebugInfo
85 // object.
86 if (CodeGenOpts.DebugInfo || CodeGenOpts.EmitGcovArcs ||
87 CodeGenOpts.EmitGcovNotes)
88 DebugInfo = new CGDebugInfo(*this);
John McCalld16c2cf2011-02-08 08:22:06 +000089
90 Block.GlobalUniqueCount = 0;
John McCall5936e332011-02-15 09:22:45 +000091
John McCallf85e1932011-06-15 23:02:42 +000092 if (C.getLangOptions().ObjCAutoRefCount)
93 ARCData = new ARCEntrypoints();
94 RRData = new RREntrypoints();
95
John McCall5936e332011-02-15 09:22:45 +000096 // Initialize the type cache.
97 llvm::LLVMContext &LLVMContext = M.getContext();
John McCall0774cb82011-05-15 01:53:33 +000098 VoidTy = llvm::Type::getVoidTy(LLVMContext);
99 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
100 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
101 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000102 PointerWidthInBits = C.getTargetInfo().getPointerWidth(0);
John McCall34695852011-02-22 06:44:22 +0000103 PointerAlignInBytes =
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000104 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(0)).getQuantity();
105 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
John McCall5936e332011-02-15 09:22:45 +0000106 IntPtrTy = llvm::IntegerType::get(LLVMContext, PointerWidthInBits);
107 Int8PtrTy = Int8Ty->getPointerTo(0);
108 Int8PtrPtrTy = Int8PtrTy->getPointerTo(0);
Chris Lattner2b94fe32008-03-01 08:45:05 +0000109}
110
111CodeGenModule::~CodeGenModule() {
Peter Collingbournee9265232011-07-27 20:29:46 +0000112 delete ObjCRuntime;
John McCallf16aa102010-08-22 21:01:12 +0000113 delete &ABI;
Dan Gohman4376c852010-10-15 18:04:46 +0000114 delete TBAA;
Ted Kremenek815c78f2008-08-05 18:50:11 +0000115 delete DebugInfo;
John McCallf85e1932011-06-15 23:02:42 +0000116 delete ARCData;
117 delete RRData;
Ted Kremenek815c78f2008-08-05 18:50:11 +0000118}
119
David Chisnall0d13f6f2010-01-23 02:40:42 +0000120void CodeGenModule::createObjCRuntime() {
121 if (!Features.NeXTRuntime)
Peter Collingbournee9265232011-07-27 20:29:46 +0000122 ObjCRuntime = CreateGNUObjCRuntime(*this);
David Chisnall0d13f6f2010-01-23 02:40:42 +0000123 else
Peter Collingbournee9265232011-07-27 20:29:46 +0000124 ObjCRuntime = CreateMacObjCRuntime(*this);
David Chisnall0d13f6f2010-01-23 02:40:42 +0000125}
126
Ted Kremenek815c78f2008-08-05 18:50:11 +0000127void CodeGenModule::Release() {
Chris Lattner82227ff2009-03-22 21:21:57 +0000128 EmitDeferred();
Eli Friedman6c6bda32010-01-08 00:50:11 +0000129 EmitCXXGlobalInitFunc();
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000130 EmitCXXGlobalDtorFunc();
Peter Collingbournee9265232011-07-27 20:29:46 +0000131 if (ObjCRuntime)
132 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
Daniel Dunbar208ff5e2008-08-11 18:12:00 +0000133 AddGlobalCtor(ObjCInitFunction);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000134 EmitCtorList(GlobalCtors, "llvm.global_ctors");
135 EmitCtorList(GlobalDtors, "llvm.global_dtors");
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000136 EmitGlobalAnnotations();
Daniel Dunbar02698712009-02-13 20:29:50 +0000137 EmitLLVMUsed();
John McCall744016d2010-07-06 23:57:41 +0000138
John McCallb2593832010-09-16 06:16:50 +0000139 SimplifyPersonality();
140
John McCall744016d2010-07-06 23:57:41 +0000141 if (getCodeGenOpts().EmitDeclMetadata)
142 EmitDeclMetadata();
Nick Lewycky5ea4f442011-05-04 20:46:58 +0000143
144 if (getCodeGenOpts().EmitGcovArcs || getCodeGenOpts().EmitGcovNotes)
Nick Lewycky3dc05412011-05-05 00:08:20 +0000145 EmitCoverageFile();
Devang Patelf391dbe2011-08-16 20:58:22 +0000146
147 if (DebugInfo)
148 DebugInfo->finalize();
Daniel Dunbarf1968f22008-10-01 00:49:24 +0000149}
150
Devang Patele80d5672011-03-23 16:29:39 +0000151void CodeGenModule::UpdateCompletedType(const TagDecl *TD) {
152 // Make sure that this type is translated.
153 Types.UpdateCompletedType(TD);
154 if (DebugInfo)
155 DebugInfo->UpdateCompletedType(TD);
156}
157
Dan Gohman3d5aff52010-10-14 23:06:10 +0000158llvm::MDNode *CodeGenModule::getTBAAInfo(QualType QTy) {
159 if (!TBAA)
160 return 0;
161 return TBAA->getTBAAInfo(QTy);
162}
163
164void CodeGenModule::DecorateInstruction(llvm::Instruction *Inst,
165 llvm::MDNode *TBAAInfo) {
166 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, TBAAInfo);
167}
168
John McCall6374c332010-03-06 00:35:14 +0000169bool CodeGenModule::isTargetDarwin() const {
Douglas Gregorbcfd1f52011-09-02 00:18:52 +0000170 return getContext().getTargetInfo().getTriple().isOSDarwin();
John McCall6374c332010-03-06 00:35:14 +0000171}
172
Chris Lattner5f9e2722011-07-23 10:55:15 +0000173void CodeGenModule::Error(SourceLocation loc, StringRef error) {
John McCall32096692011-03-18 02:56:14 +0000174 unsigned diagID = getDiags().getCustomDiagID(Diagnostic::Error, error);
175 getDiags().Report(Context.getFullLoc(loc), diagID);
176}
177
Daniel Dunbar488e9932008-08-16 00:56:44 +0000178/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattner2c8569d2007-12-02 07:19:18 +0000179/// specified stmt yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000180void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
181 bool OmitOnError) {
182 if (OmitOnError && getDiags().hasErrorOccurred())
183 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000184 unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
Daniel Dunbar56b80012009-02-06 19:18:03 +0000185 "cannot compile this %0 yet");
Chris Lattner2c8569d2007-12-02 07:19:18 +0000186 std::string Msg = Type;
Chris Lattner0a14eee2008-11-18 07:04:44 +0000187 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
188 << Msg << S->getSourceRange();
Chris Lattner2c8569d2007-12-02 07:19:18 +0000189}
Chris Lattner58c3f9e2007-12-02 06:27:33 +0000190
Daniel Dunbar488e9932008-08-16 00:56:44 +0000191/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000192/// specified decl yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000193void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
194 bool OmitOnError) {
195 if (OmitOnError && getDiags().hasErrorOccurred())
196 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000197 unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
Daniel Dunbar56b80012009-02-06 19:18:03 +0000198 "cannot compile this %0 yet");
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000199 std::string Msg = Type;
Chris Lattner0a14eee2008-11-18 07:04:44 +0000200 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000201}
202
John McCallbc8d40d2011-06-24 21:55:10 +0000203llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
204 return llvm::ConstantInt::get(SizeTy, size.getQuantity());
205}
206
Mike Stump1eb44332009-09-09 15:08:12 +0000207void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
Anders Carlsson0ffeaad2011-01-29 19:39:23 +0000208 const NamedDecl *D) const {
Daniel Dunbar04d40782009-04-14 06:00:08 +0000209 // Internal definitions always have default visibility.
Chris Lattnerdf102fc2009-04-14 05:27:13 +0000210 if (GV->hasLocalLinkage()) {
Daniel Dunbar7e714cd2009-04-10 20:26:50 +0000211 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar6ab187a2009-04-07 05:48:37 +0000212 return;
Daniel Dunbar7e714cd2009-04-10 20:26:50 +0000213 }
Daniel Dunbar6ab187a2009-04-07 05:48:37 +0000214
John McCallaf146032010-10-30 11:50:40 +0000215 // Set visibility for definitions.
216 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility();
Fariborz Jahanianc7c90582011-06-16 20:14:50 +0000217 if (LV.visibilityExplicit() || !GV->hasAvailableExternallyLinkage())
218 GV->setVisibility(GetLLVMVisibility(LV.visibility()));
Dan Gohman4f8d1232008-05-22 00:50:06 +0000219}
220
John McCallcbfe5022010-08-04 08:34:44 +0000221/// Set the symbol visibility of type information (vtable and RTTI)
222/// associated with the given type.
223void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV,
224 const CXXRecordDecl *RD,
Anders Carlssonfa2e99f2011-01-29 20:24:48 +0000225 TypeVisibilityKind TVK) const {
Anders Carlsson0ffeaad2011-01-29 19:39:23 +0000226 setGlobalVisibility(GV, RD);
John McCallcbfe5022010-08-04 08:34:44 +0000227
John McCall279b5eb2010-08-12 23:36:15 +0000228 if (!CodeGenOpts.HiddenWeakVTables)
229 return;
230
Anders Carlsson9a86a132011-01-29 20:36:11 +0000231 // We never want to drop the visibility for RTTI names.
232 if (TVK == TVK_ForRTTIName)
233 return;
234
John McCallcbfe5022010-08-04 08:34:44 +0000235 // We want to drop the visibility to hidden for weak type symbols.
236 // This isn't possible if there might be unresolved references
237 // elsewhere that rely on this symbol being visible.
238
John McCall7a536902010-08-05 20:39:18 +0000239 // This should be kept roughly in sync with setThunkVisibility
240 // in CGVTables.cpp.
241
John McCallcbfe5022010-08-04 08:34:44 +0000242 // Preconditions.
Anders Carlssonf502d932011-01-24 00:46:19 +0000243 if (GV->getLinkage() != llvm::GlobalVariable::LinkOnceODRLinkage ||
John McCallcbfe5022010-08-04 08:34:44 +0000244 GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
245 return;
246
247 // Don't override an explicit visibility attribute.
Douglas Gregor4421d2b2011-03-26 12:10:19 +0000248 if (RD->getExplicitVisibility())
John McCallcbfe5022010-08-04 08:34:44 +0000249 return;
250
251 switch (RD->getTemplateSpecializationKind()) {
252 // We have to disable the optimization if this is an EI definition
253 // because there might be EI declarations in other shared objects.
254 case TSK_ExplicitInstantiationDefinition:
255 case TSK_ExplicitInstantiationDeclaration:
256 return;
257
John McCall7a536902010-08-05 20:39:18 +0000258 // Every use of a non-template class's type information has to emit it.
John McCallcbfe5022010-08-04 08:34:44 +0000259 case TSK_Undeclared:
260 break;
261
John McCall7a536902010-08-05 20:39:18 +0000262 // In theory, implicit instantiations can ignore the possibility of
263 // an explicit instantiation declaration because there necessarily
264 // must be an EI definition somewhere with default visibility. In
265 // practice, it's possible to have an explicit instantiation for
266 // an arbitrary template class, and linkers aren't necessarily able
267 // to deal with mixed-visibility symbols.
268 case TSK_ExplicitSpecialization:
John McCallcbfe5022010-08-04 08:34:44 +0000269 case TSK_ImplicitInstantiation:
John McCall279b5eb2010-08-12 23:36:15 +0000270 if (!CodeGenOpts.HiddenWeakTemplateVTables)
John McCall7a536902010-08-05 20:39:18 +0000271 return;
John McCallcbfe5022010-08-04 08:34:44 +0000272 break;
273 }
274
275 // If there's a key function, there may be translation units
276 // that don't have the key function's definition. But ignore
277 // this if we're emitting RTTI under -fno-rtti.
Anders Carlssonfa2e99f2011-01-29 20:24:48 +0000278 if (!(TVK != TVK_ForRTTI) || Features.RTTI) {
John McCallcbfe5022010-08-04 08:34:44 +0000279 if (Context.getKeyFunction(RD))
280 return;
Anders Carlssonfa2e99f2011-01-29 20:24:48 +0000281 }
John McCallcbfe5022010-08-04 08:34:44 +0000282
283 // Otherwise, drop the visibility to hidden.
284 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Rafael Espindolab1c65ff2011-01-11 21:44:37 +0000285 GV->setUnnamedAddr(true);
John McCallcbfe5022010-08-04 08:34:44 +0000286}
287
Chris Lattner5f9e2722011-07-23 10:55:15 +0000288StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
Anders Carlsson793a9902010-06-22 16:05:32 +0000289 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
290
Chris Lattner5f9e2722011-07-23 10:55:15 +0000291 StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()];
Anders Carlsson793a9902010-06-22 16:05:32 +0000292 if (!Str.empty())
293 return Str;
294
John McCall4c40d982010-08-31 07:33:07 +0000295 if (!getCXXABI().getMangleContext().shouldMangleDeclName(ND)) {
Anders Carlsson793a9902010-06-22 16:05:32 +0000296 IdentifierInfo *II = ND->getIdentifier();
297 assert(II && "Attempt to mangle unnamed decl.");
298
299 Str = II->getName();
300 return Str;
301 }
302
303 llvm::SmallString<256> Buffer;
Rafael Espindolac4850c22011-02-10 23:59:36 +0000304 llvm::raw_svector_ostream Out(Buffer);
Anders Carlsson793a9902010-06-22 16:05:32 +0000305 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000306 getCXXABI().getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000307 else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000308 getCXXABI().getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000309 else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000310 getCXXABI().getMangleContext().mangleBlock(BD, Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000311 else
Rafael Espindolac4850c22011-02-10 23:59:36 +0000312 getCXXABI().getMangleContext().mangleName(ND, Out);
Anders Carlsson793a9902010-06-22 16:05:32 +0000313
314 // Allocate space for the mangled name.
Rafael Espindolac4850c22011-02-10 23:59:36 +0000315 Out.flush();
Anders Carlsson793a9902010-06-22 16:05:32 +0000316 size_t Length = Buffer.size();
317 char *Name = MangledNamesAllocator.Allocate<char>(Length);
318 std::copy(Buffer.begin(), Buffer.end(), Name);
319
Chris Lattner5f9e2722011-07-23 10:55:15 +0000320 Str = StringRef(Name, Length);
Anders Carlsson793a9902010-06-22 16:05:32 +0000321
322 return Str;
323}
324
Peter Collingbourne14110472011-01-13 18:57:25 +0000325void CodeGenModule::getBlockMangledName(GlobalDecl GD, MangleBuffer &Buffer,
326 const BlockDecl *BD) {
327 MangleContext &MangleCtx = getCXXABI().getMangleContext();
328 const Decl *D = GD.getDecl();
Rafael Espindolac4850c22011-02-10 23:59:36 +0000329 llvm::raw_svector_ostream Out(Buffer.getBuffer());
Peter Collingbourne14110472011-01-13 18:57:25 +0000330 if (D == 0)
Rafael Espindolac4850c22011-02-10 23:59:36 +0000331 MangleCtx.mangleGlobalBlock(BD, Out);
Peter Collingbourne14110472011-01-13 18:57:25 +0000332 else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000333 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
Peter Collingbourne14110472011-01-13 18:57:25 +0000334 else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D))
Rafael Espindolac4850c22011-02-10 23:59:36 +0000335 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
Peter Collingbourne14110472011-01-13 18:57:25 +0000336 else
Rafael Espindolac4850c22011-02-10 23:59:36 +0000337 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
Anders Carlsson9a8822b2010-06-09 02:36:32 +0000338}
339
Chris Lattner5f9e2722011-07-23 10:55:15 +0000340llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
John McCallf746aa62010-03-19 23:29:14 +0000341 return getModule().getNamedValue(Name);
Douglas Gregor5f2bfd42009-02-13 00:10:09 +0000342}
343
Chris Lattner6d397602008-03-14 17:18:18 +0000344/// AddGlobalCtor - Add a function to the list that will be called before
345/// main() runs.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000346void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
Daniel Dunbar49988882009-01-13 02:25:00 +0000347 // FIXME: Type coercion of void()* types.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000348 GlobalCtors.push_back(std::make_pair(Ctor, Priority));
Chris Lattner6d397602008-03-14 17:18:18 +0000349}
350
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000351/// AddGlobalDtor - Add a function to the list that will be called
352/// when the module is unloaded.
353void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
Daniel Dunbar49988882009-01-13 02:25:00 +0000354 // FIXME: Type coercion of void()* types.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000355 GlobalDtors.push_back(std::make_pair(Dtor, Priority));
356}
357
358void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
359 // Ctor function type is void()*.
John McCall0774cb82011-05-15 01:53:33 +0000360 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000361 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000362
363 // Get the type of a ctor entry, { i32, void ()* }.
Chris Lattnerc5cbb902011-06-20 04:01:35 +0000364 llvm::StructType *CtorStructTy =
Chris Lattner7650d952011-06-18 22:49:11 +0000365 llvm::StructType::get(llvm::Type::getInt32Ty(VMContext),
Owen Anderson96e0fc72009-07-29 22:16:19 +0000366 llvm::PointerType::getUnqual(CtorFTy), NULL);
Chris Lattner6d397602008-03-14 17:18:18 +0000367
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000368 // Construct the constructor and destructor arrays.
369 std::vector<llvm::Constant*> Ctors;
370 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
371 std::vector<llvm::Constant*> S;
Mike Stump1eb44332009-09-09 15:08:12 +0000372 S.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
Owen Anderson0032b272009-08-13 21:57:51 +0000373 I->second, false));
Owen Anderson3c4972d2009-07-29 18:54:39 +0000374 S.push_back(llvm::ConstantExpr::getBitCast(I->first, CtorPFTy));
Owen Anderson08e25242009-07-27 22:29:56 +0000375 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
Chris Lattner6d397602008-03-14 17:18:18 +0000376 }
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000377
378 if (!Ctors.empty()) {
Owen Anderson96e0fc72009-07-29 22:16:19 +0000379 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
Owen Anderson1c431b32009-07-08 19:05:04 +0000380 new llvm::GlobalVariable(TheModule, AT, false,
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000381 llvm::GlobalValue::AppendingLinkage,
Owen Anderson7db6d832009-07-28 18:33:04 +0000382 llvm::ConstantArray::get(AT, Ctors),
Owen Anderson1c431b32009-07-08 19:05:04 +0000383 GlobalName);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000384 }
Chris Lattner6d397602008-03-14 17:18:18 +0000385}
386
John McCalld46f9852010-02-19 01:32:20 +0000387llvm::GlobalValue::LinkageTypes
388CodeGenModule::getFunctionLinkage(const FunctionDecl *D) {
Argyrios Kyrtzidis90e99a82010-07-29 18:15:58 +0000389 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000390
Chris Lattnerf81530652010-06-30 16:58:07 +0000391 if (Linkage == GVA_Internal)
John McCalld46f9852010-02-19 01:32:20 +0000392 return llvm::Function::InternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000393
394 if (D->hasAttr<DLLExportAttr>())
John McCalld46f9852010-02-19 01:32:20 +0000395 return llvm::Function::DLLExportLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000396
397 if (D->hasAttr<WeakAttr>())
John McCalld46f9852010-02-19 01:32:20 +0000398 return llvm::Function::WeakAnyLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000399
400 // In C99 mode, 'inline' functions are guaranteed to have a strong
401 // definition somewhere else, so we can use available_externally linkage.
402 if (Linkage == GVA_C99Inline)
Fariborz Jahanianfd0f89d2011-02-04 00:08:13 +0000403 return llvm::Function::AvailableExternallyLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000404
405 // In C++, the compiler has to emit a definition in every translation unit
406 // that references the function. We should use linkonce_odr because
407 // a) if all references in this translation unit are optimized away, we
408 // don't need to codegen it. b) if the function persists, it needs to be
409 // merged with other definitions. c) C++ has the ODR, so we know the
410 // definition is dependable.
411 if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
Fariborz Jahanian142f9e92011-02-04 00:01:24 +0000412 return !Context.getLangOptions().AppleKext
413 ? llvm::Function::LinkOnceODRLinkage
414 : llvm::Function::InternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000415
416 // An explicit instantiation of a template has weak linkage, since
417 // explicit instantiations can occur in multiple translation units
418 // and must all be equivalent. However, we are not allowed to
419 // throw away these explicit instantiations.
420 if (Linkage == GVA_ExplicitTemplateInstantiation)
Fariborz Jahanian142f9e92011-02-04 00:01:24 +0000421 return !Context.getLangOptions().AppleKext
422 ? llvm::Function::WeakODRLinkage
423 : llvm::Function::InternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000424
425 // Otherwise, we have strong external linkage.
426 assert(Linkage == GVA_StrongExternal);
427 return llvm::Function::ExternalLinkage;
John McCalld46f9852010-02-19 01:32:20 +0000428}
Nuno Lopesd4cbda62008-06-08 15:45:52 +0000429
John McCalld46f9852010-02-19 01:32:20 +0000430
431/// SetFunctionDefinitionAttributes - Set attributes for a global.
432///
433/// FIXME: This is currently only done for aliases and functions, but not for
434/// variables (these details are set in EmitGlobalVarDefinition for variables).
435void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
436 llvm::GlobalValue *GV) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000437 SetCommonAttributes(D, GV);
Nuno Lopesd4cbda62008-06-08 15:45:52 +0000438}
439
Daniel Dunbar7dbd8192009-04-14 07:08:30 +0000440void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
Mike Stump1eb44332009-09-09 15:08:12 +0000441 const CGFunctionInfo &Info,
Daniel Dunbar7dbd8192009-04-14 07:08:30 +0000442 llvm::Function *F) {
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000443 unsigned CallingConv;
Devang Patel761d7f72008-09-25 21:02:23 +0000444 AttributeListType AttributeList;
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000445 ConstructAttributeList(Info, D, AttributeList, CallingConv);
Devang Patel761d7f72008-09-25 21:02:23 +0000446 F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(),
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000447 AttributeList.size()));
448 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000449}
450
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000451void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
452 llvm::Function *F) {
Rafael Espindolaabca5a12011-05-25 03:44:55 +0000453 if (CodeGenOpts.UnwindTables)
454 F->setHasUWTable();
455
Daniel Dunbar74ac74a2009-03-02 04:58:03 +0000456 if (!Features.Exceptions && !Features.ObjCNonFragileABI)
Mike Stump1eb44332009-09-09 15:08:12 +0000457 F->addFnAttr(llvm::Attribute::NoUnwind);
Daniel Dunbaraf668b02008-10-28 00:17:57 +0000458
Eli Friedman2873aee2011-08-22 23:55:33 +0000459 if (D->hasAttr<NakedAttr>()) {
460 // Naked implies noinline: we should not be inlining such functions.
Daniel Dunbardd0cb222010-09-29 18:20:25 +0000461 F->addFnAttr(llvm::Attribute::Naked);
Eli Friedman2873aee2011-08-22 23:55:33 +0000462 F->addFnAttr(llvm::Attribute::NoInline);
463 }
Daniel Dunbardd0cb222010-09-29 18:20:25 +0000464
Mike Stump1feade82009-08-26 22:31:08 +0000465 if (D->hasAttr<NoInlineAttr>())
Anders Carlsson81ebbde2009-02-19 19:22:11 +0000466 F->addFnAttr(llvm::Attribute::NoInline);
Mike Stumpf55314d2009-10-05 21:58:44 +0000467
Eli Friedman2873aee2011-08-22 23:55:33 +0000468 // (noinline wins over always_inline, and we can't specify both in IR)
469 if (D->hasAttr<AlwaysInlineAttr>() &&
470 !F->hasFnAttr(llvm::Attribute::NoInline))
471 F->addFnAttr(llvm::Attribute::AlwaysInline);
472
Rafael Espindolac5f657f2011-01-11 00:26:26 +0000473 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
474 F->setUnnamedAddr(true);
475
Anders Carlssonfd015352009-11-16 16:56:03 +0000476 if (Features.getStackProtectorMode() == LangOptions::SSPOn)
477 F->addFnAttr(llvm::Attribute::StackProtect);
478 else if (Features.getStackProtectorMode() == LangOptions::SSPReq)
479 F->addFnAttr(llvm::Attribute::StackProtectReq);
480
Sean Huntcf807c42010-08-18 23:23:40 +0000481 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
482 if (alignment)
483 F->setAlignment(alignment);
484
Mike Stumpfb51ddf2009-10-05 22:49:20 +0000485 // C++ ABI requires 2-byte alignment for member functions.
Mike Stumpbd6dbd12009-10-05 23:08:21 +0000486 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
487 F->setAlignment(2);
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000488}
489
Mike Stump1eb44332009-09-09 15:08:12 +0000490void CodeGenModule::SetCommonAttributes(const Decl *D,
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000491 llvm::GlobalValue *GV) {
Anders Carlsson934176f2011-01-29 19:41:00 +0000492 if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
493 setGlobalVisibility(GV, ND);
John McCall1fb0caa2010-10-22 21:05:15 +0000494 else
495 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000496
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000497 if (D->hasAttr<UsedAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000498 AddUsedGlobal(GV);
499
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000500 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000501 GV->setSection(SA->getName());
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000502
503 getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000504}
505
Daniel Dunbar0e4f40e2009-04-17 00:48:04 +0000506void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
507 llvm::Function *F,
508 const CGFunctionInfo &FI) {
509 SetLLVMFunctionAttributes(D, FI, F);
510 SetLLVMFunctionAttributesForDefinition(D, F);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000511
512 F->setLinkage(llvm::Function::InternalLinkage);
513
Daniel Dunbar0e4f40e2009-04-17 00:48:04 +0000514 SetCommonAttributes(D, F);
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000515}
516
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000517void CodeGenModule::SetFunctionAttributes(GlobalDecl GD,
Eli Friedmanc6c14d12009-05-26 01:22:57 +0000518 llvm::Function *F,
519 bool IsIncompleteFunction) {
Peter Collingbourne0ac2cf42011-04-06 12:29:04 +0000520 if (unsigned IID = F->getIntrinsicID()) {
521 // If this is an intrinsic function, set the function's attributes
522 // to the intrinsic's attributes.
523 F->setAttributes(llvm::Intrinsic::getAttributes((llvm::Intrinsic::ID)IID));
524 return;
525 }
526
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000527 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
528
Eli Friedmanc6c14d12009-05-26 01:22:57 +0000529 if (!IsIncompleteFunction)
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000530 SetLLVMFunctionAttributes(FD, getTypes().getFunctionInfo(GD), F);
Mike Stump1eb44332009-09-09 15:08:12 +0000531
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000532 // Only a few attributes are set on declarations; these may later be
533 // overridden by a definition.
Mike Stump1eb44332009-09-09 15:08:12 +0000534
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000535 if (FD->hasAttr<DLLImportAttr>()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000536 F->setLinkage(llvm::Function::DLLImportLinkage);
Mike Stump1eb44332009-09-09 15:08:12 +0000537 } else if (FD->hasAttr<WeakAttr>() ||
Douglas Gregor0a0d2b12011-03-23 00:50:03 +0000538 FD->isWeakImported()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000539 // "extern_weak" is overloaded in LLVM; we probably should have
Mike Stump1eb44332009-09-09 15:08:12 +0000540 // separate linkage types for this.
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000541 F->setLinkage(llvm::Function::ExternalWeakLinkage);
542 } else {
Mike Stump1eb44332009-09-09 15:08:12 +0000543 F->setLinkage(llvm::Function::ExternalLinkage);
John McCallaf146032010-10-30 11:50:40 +0000544
545 NamedDecl::LinkageInfo LV = FD->getLinkageAndVisibility();
546 if (LV.linkage() == ExternalLinkage && LV.visibilityExplicit()) {
547 F->setVisibility(GetLLVMVisibility(LV.visibility()));
548 }
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000549 }
550
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000551 if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000552 F->setSection(SA->getName());
Daniel Dunbar219df662008-09-08 23:44:31 +0000553}
554
Daniel Dunbar02698712009-02-13 20:29:50 +0000555void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
Mike Stump1eb44332009-09-09 15:08:12 +0000556 assert(!GV->isDeclaration() &&
Daniel Dunbar02698712009-02-13 20:29:50 +0000557 "Only globals with definition can force usage.");
Chris Lattner35f38a22009-03-31 22:37:52 +0000558 LLVMUsed.push_back(GV);
Daniel Dunbar02698712009-02-13 20:29:50 +0000559}
560
561void CodeGenModule::EmitLLVMUsed() {
562 // Don't create llvm.used if there is no need.
Chris Lattnerad64e022009-07-17 23:57:13 +0000563 if (LLVMUsed.empty())
Daniel Dunbar02698712009-02-13 20:29:50 +0000564 return;
565
Chris Lattner2acc6e32011-07-18 04:24:23 +0000566 llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext);
Mike Stump1eb44332009-09-09 15:08:12 +0000567
Chris Lattner35f38a22009-03-31 22:37:52 +0000568 // Convert LLVMUsed to what ConstantArray needs.
569 std::vector<llvm::Constant*> UsedArray;
570 UsedArray.resize(LLVMUsed.size());
571 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
Mike Stump1eb44332009-09-09 15:08:12 +0000572 UsedArray[i] =
573 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
Owen Andersona1cf15f2009-07-14 23:10:40 +0000574 i8PTy);
Chris Lattner35f38a22009-03-31 22:37:52 +0000575 }
Mike Stump1eb44332009-09-09 15:08:12 +0000576
Fariborz Jahanianc38e9af2009-06-23 21:47:46 +0000577 if (UsedArray.empty())
578 return;
Owen Anderson96e0fc72009-07-29 22:16:19 +0000579 llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, UsedArray.size());
Mike Stump1eb44332009-09-09 15:08:12 +0000580
581 llvm::GlobalVariable *GV =
582 new llvm::GlobalVariable(getModule(), ATy, false,
Daniel Dunbar02698712009-02-13 20:29:50 +0000583 llvm::GlobalValue::AppendingLinkage,
Owen Anderson7db6d832009-07-28 18:33:04 +0000584 llvm::ConstantArray::get(ATy, UsedArray),
Owen Anderson1c431b32009-07-08 19:05:04 +0000585 "llvm.used");
Daniel Dunbar02698712009-02-13 20:29:50 +0000586
587 GV->setSection("llvm.metadata");
588}
589
590void CodeGenModule::EmitDeferred() {
Chris Lattner67b00522009-03-21 09:44:56 +0000591 // Emit code for any potentially referenced deferred decls. Since a
592 // previously unused static decl may become used during the generation of code
Nick Lewyckydce67a72011-07-18 05:26:13 +0000593 // for a static function, iterate until no changes are made.
Rafael Espindolabbf58bb2010-03-10 02:19:29 +0000594
Anders Carlsson046c2942010-04-17 20:15:18 +0000595 while (!DeferredDeclsToEmit.empty() || !DeferredVTables.empty()) {
596 if (!DeferredVTables.empty()) {
597 const CXXRecordDecl *RD = DeferredVTables.back();
598 DeferredVTables.pop_back();
599 getVTables().GenerateClassData(getVTableLinkage(RD), RD);
Rafael Espindolabbf58bb2010-03-10 02:19:29 +0000600 continue;
601 }
602
Anders Carlsson2a131fb2009-05-05 04:44:02 +0000603 GlobalDecl D = DeferredDeclsToEmit.back();
Chris Lattner67b00522009-03-21 09:44:56 +0000604 DeferredDeclsToEmit.pop_back();
605
John McCallc76702c2010-05-27 01:45:30 +0000606 // Check to see if we've already emitted this. This is necessary
607 // for a couple of reasons: first, decls can end up in the
608 // deferred-decls queue multiple times, and second, decls can end
609 // up with definitions in unusual ways (e.g. by an extern inline
610 // function acquiring a strong function redefinition). Just
611 // ignore these cases.
612 //
613 // TODO: That said, looking this up multiple times is very wasteful.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000614 StringRef Name = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +0000615 llvm::GlobalValue *CGRef = GetGlobalValue(Name);
Chris Lattner67b00522009-03-21 09:44:56 +0000616 assert(CGRef && "Deferred decl wasn't referenced?");
Mike Stump1eb44332009-09-09 15:08:12 +0000617
Chris Lattner67b00522009-03-21 09:44:56 +0000618 if (!CGRef->isDeclaration())
619 continue;
Mike Stump1eb44332009-09-09 15:08:12 +0000620
John McCallc76702c2010-05-27 01:45:30 +0000621 // GlobalAlias::isDeclaration() defers to the aliasee, but for our
622 // purposes an alias counts as a definition.
623 if (isa<llvm::GlobalAlias>(CGRef))
624 continue;
625
Chris Lattner67b00522009-03-21 09:44:56 +0000626 // Otherwise, emit the definition and move on to the next one.
627 EmitGlobalDefinition(D);
628 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000629}
630
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000631void CodeGenModule::EmitGlobalAnnotations() {
632 if (Annotations.empty())
633 return;
634
635 // Create a new global variable for the ConstantStruct in the Module.
636 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
637 Annotations[0]->getType(), Annotations.size()), Annotations);
638 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(),
639 Array->getType(), false, llvm::GlobalValue::AppendingLinkage, Array,
640 "llvm.global.annotations");
641 gv->setSection(AnnotationSection);
642}
643
644llvm::Constant *CodeGenModule::EmitAnnotationString(llvm::StringRef Str) {
645 llvm::StringMap<llvm::Constant*>::iterator i = AnnotationStrings.find(Str);
646 if (i != AnnotationStrings.end())
647 return i->second;
648
649 // Not found yet, create a new global.
650 llvm::Constant *s = llvm::ConstantArray::get(getLLVMContext(), Str, true);
651 llvm::GlobalValue *gv = new llvm::GlobalVariable(getModule(), s->getType(),
652 true, llvm::GlobalValue::PrivateLinkage, s, ".str");
653 gv->setSection(AnnotationSection);
654 gv->setUnnamedAddr(true);
655 AnnotationStrings[Str] = gv;
656 return gv;
657}
658
659llvm::Constant *CodeGenModule::EmitAnnotationUnit(SourceLocation Loc) {
660 SourceManager &SM = getContext().getSourceManager();
661 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
662 if (PLoc.isValid())
663 return EmitAnnotationString(PLoc.getFilename());
664 return EmitAnnotationString(SM.getBufferName(Loc));
665}
666
667llvm::Constant *CodeGenModule::EmitAnnotationLineNo(SourceLocation L) {
668 SourceManager &SM = getContext().getSourceManager();
669 PresumedLoc PLoc = SM.getPresumedLoc(L);
670 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
671 SM.getExpansionLineNumber(L);
672 return llvm::ConstantInt::get(Int32Ty, LineNo);
673}
674
Mike Stump1eb44332009-09-09 15:08:12 +0000675llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000676 const AnnotateAttr *AA,
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000677 SourceLocation L) {
678 // Get the globals for file name, annotation, and the line number.
679 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
680 *UnitGV = EmitAnnotationUnit(L),
681 *LineNoCst = EmitAnnotationLineNo(L);
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000682
Daniel Dunbar57d5cee2009-04-14 22:41:13 +0000683 // Create the ConstantStruct for the global annotation.
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000684 llvm::Constant *Fields[4] = {
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000685 llvm::ConstantExpr::getBitCast(GV, Int8PtrTy),
686 llvm::ConstantExpr::getBitCast(AnnoGV, Int8PtrTy),
687 llvm::ConstantExpr::getBitCast(UnitGV, Int8PtrTy),
688 LineNoCst
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000689 };
Chris Lattnerc5cbb902011-06-20 04:01:35 +0000690 return llvm::ConstantStruct::getAnon(Fields);
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000691}
692
Julien Lerouge77f68bb2011-09-09 22:41:49 +0000693void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
694 llvm::GlobalValue *GV) {
695 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
696 // Get the struct elements for these annotations.
697 for (specific_attr_iterator<AnnotateAttr>
698 ai = D->specific_attr_begin<AnnotateAttr>(),
699 ae = D->specific_attr_end<AnnotateAttr>(); ai != ae; ++ai)
700 Annotations.push_back(EmitAnnotateAttr(GV, *ai, D->getLocation()));
701}
702
Argyrios Kyrtzidisa6d6af32010-07-27 22:37:14 +0000703bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
Argyrios Kyrtzidis90e99a82010-07-29 18:15:58 +0000704 // Never defer when EmitAllDecls is specified.
705 if (Features.EmitAllDecls)
Daniel Dunbar73241df2009-02-13 21:18:01 +0000706 return false;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000707
Argyrios Kyrtzidis4ac7c0b2010-07-29 20:08:05 +0000708 return !getContext().DeclMustBeEmitted(Global);
Daniel Dunbar73241df2009-02-13 21:18:01 +0000709}
710
Rafael Espindola6a836702010-03-04 18:17:24 +0000711llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
712 const AliasAttr *AA = VD->getAttr<AliasAttr>();
713 assert(AA && "No alias?");
714
Chris Lattner2acc6e32011-07-18 04:24:23 +0000715 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
Rafael Espindola6a836702010-03-04 18:17:24 +0000716
Rafael Espindola6a836702010-03-04 18:17:24 +0000717 // See if there is already something with the target's name in the module.
John McCallf746aa62010-03-19 23:29:14 +0000718 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
Rafael Espindola6a836702010-03-04 18:17:24 +0000719
720 llvm::Constant *Aliasee;
721 if (isa<llvm::FunctionType>(DeclTy))
Anders Carlsson1faa89f2011-02-05 04:35:53 +0000722 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl(),
723 /*ForVTable=*/false);
Rafael Espindola6a836702010-03-04 18:17:24 +0000724 else
John McCallf746aa62010-03-19 23:29:14 +0000725 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Rafael Espindola6a836702010-03-04 18:17:24 +0000726 llvm::PointerType::getUnqual(DeclTy), 0);
727 if (!Entry) {
728 llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee);
729 F->setLinkage(llvm::Function::ExternalWeakLinkage);
730 WeakRefReferences.insert(F);
731 }
732
733 return Aliasee;
734}
735
Chris Lattnerb4880ba2009-05-12 21:21:08 +0000736void CodeGenModule::EmitGlobal(GlobalDecl GD) {
Anders Carlsson4a6835e2009-09-10 23:38:47 +0000737 const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +0000738
Rafael Espindola6a836702010-03-04 18:17:24 +0000739 // Weak references don't produce any output by themselves.
740 if (Global->hasAttr<WeakRefAttr>())
741 return;
742
Chris Lattnerbd532712009-03-22 21:47:11 +0000743 // If this is an alias definition (which otherwise looks like a declaration)
744 // emit it now.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000745 if (Global->hasAttr<AliasAttr>())
John McCallf746aa62010-03-19 23:29:14 +0000746 return EmitAliasDefinition(GD);
Daniel Dunbar219df662008-09-08 23:44:31 +0000747
Chris Lattner67b00522009-03-21 09:44:56 +0000748 // Ignore declarations, they will be emitted on their first use.
Daniel Dunbar5e1e1f92009-03-19 08:27:24 +0000749 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
Daniel Dunbar73241df2009-02-13 21:18:01 +0000750 // Forward declarations are emitted lazily on first use.
Nick Lewyckydce67a72011-07-18 05:26:13 +0000751 if (!FD->doesThisDeclarationHaveABody()) {
752 if (!FD->doesDeclarationForceExternallyVisibleDefinition())
753 return;
754
755 const FunctionDecl *InlineDefinition = 0;
756 FD->getBody(InlineDefinition);
757
Chris Lattner5f9e2722011-07-23 10:55:15 +0000758 StringRef MangledName = getMangledName(GD);
Nick Lewyckydce67a72011-07-18 05:26:13 +0000759 llvm::StringMap<GlobalDecl>::iterator DDI =
760 DeferredDecls.find(MangledName);
761 if (DDI != DeferredDecls.end())
762 DeferredDecls.erase(DDI);
763 EmitGlobalDefinition(InlineDefinition);
Daniel Dunbar73241df2009-02-13 21:18:01 +0000764 return;
Nick Lewyckydce67a72011-07-18 05:26:13 +0000765 }
Daniel Dunbar02698712009-02-13 20:29:50 +0000766 } else {
767 const VarDecl *VD = cast<VarDecl>(Global);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000768 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
769
Douglas Gregora9a55c02010-02-06 05:15:45 +0000770 if (VD->isThisDeclarationADefinition() != VarDecl::Definition)
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000771 return;
Nate Begeman4c13b7a2008-04-20 06:29:50 +0000772 }
773
Chris Lattner67b00522009-03-21 09:44:56 +0000774 // Defer code generation when possible if this is a static definition, inline
775 // function etc. These we only want to emit if they are used.
Chris Lattner4357a822010-04-13 17:39:09 +0000776 if (!MayDeferGeneration(Global)) {
777 // Emit the definition if it can't be deferred.
778 EmitGlobalDefinition(GD);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000779 return;
780 }
John McCallbf40cb52010-07-15 23:40:35 +0000781
782 // If we're deferring emission of a C++ variable with an
783 // initializer, remember the order in which it appeared in the file.
784 if (getLangOptions().CPlusPlus && isa<VarDecl>(Global) &&
785 cast<VarDecl>(Global)->hasInit()) {
786 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
787 CXXGlobalInits.push_back(0);
788 }
Chris Lattner4357a822010-04-13 17:39:09 +0000789
790 // If the value has already been used, add it directly to the
791 // DeferredDeclsToEmit list.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000792 StringRef MangledName = getMangledName(GD);
Chris Lattner4357a822010-04-13 17:39:09 +0000793 if (GetGlobalValue(MangledName))
794 DeferredDeclsToEmit.push_back(GD);
795 else {
796 // Otherwise, remember that we saw a deferred decl with this name. The
797 // first use of the mangled name will cause it to move into
798 // DeferredDeclsToEmit.
799 DeferredDecls[MangledName] = GD;
800 }
Nate Begeman4c13b7a2008-04-20 06:29:50 +0000801}
802
Chris Lattnerb4880ba2009-05-12 21:21:08 +0000803void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
Anders Carlsson4a6835e2009-09-10 23:38:47 +0000804 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +0000805
Dan Gohmancb421fa2010-04-19 16:39:44 +0000806 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
Anders Carlsson8e2efcc2009-10-27 14:32:27 +0000807 Context.getSourceManager(),
808 "Generating code for declaration");
809
Douglas Gregor44eac332010-07-13 06:02:28 +0000810 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
811 // At -O0, don't generate IR for functions with available_externally
812 // linkage.
Douglas Gregor7feaeee2010-07-15 22:58:18 +0000813 if (CodeGenOpts.OptimizationLevel == 0 &&
814 !Function->hasAttr<AlwaysInlineAttr>() &&
Douglas Gregor44eac332010-07-13 06:02:28 +0000815 getFunctionLinkage(Function)
816 == llvm::Function::AvailableExternallyLinkage)
817 return;
Anders Carlsson7270ee42010-03-23 04:31:31 +0000818
Douglas Gregor44eac332010-07-13 06:02:28 +0000819 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
Eli Friedman7dcdf5b2011-05-06 17:27:27 +0000820 // Make sure to emit the definition(s) before we emit the thunks.
821 // This is necessary for the generation of certain thunks.
822 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
823 EmitCXXConstructor(CD, GD.getCtorType());
824 else if (const CXXDestructorDecl *DD =dyn_cast<CXXDestructorDecl>(Method))
825 EmitCXXDestructor(DD, GD.getDtorType());
826 else
827 EmitGlobalFunctionDefinition(GD);
828
Douglas Gregor44eac332010-07-13 06:02:28 +0000829 if (Method->isVirtual())
830 getVTables().EmitThunks(GD);
831
Eli Friedman7dcdf5b2011-05-06 17:27:27 +0000832 return;
Douglas Gregor44eac332010-07-13 06:02:28 +0000833 }
Chris Lattnerb5e81562010-04-13 17:57:11 +0000834
Chris Lattnerb5e81562010-04-13 17:57:11 +0000835 return EmitGlobalFunctionDefinition(GD);
Douglas Gregor44eac332010-07-13 06:02:28 +0000836 }
Chris Lattnerb5e81562010-04-13 17:57:11 +0000837
838 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
839 return EmitGlobalVarDefinition(VD);
Chris Lattner4357a822010-04-13 17:39:09 +0000840
841 assert(0 && "Invalid argument to EmitGlobalDefinition()");
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000842}
843
Chris Lattner74391b42009-03-22 21:03:39 +0000844/// GetOrCreateLLVMFunction - If the specified mangled name is not in the
845/// module, create and return an llvm Function with the specified type. If there
846/// is something in the module with the specified name, return it potentially
847/// bitcasted to the right type.
848///
849/// If D is non-null, it specifies a decl that correspond to this. This is used
850/// to set the attributes on the function when it is first created.
John McCallf746aa62010-03-19 23:29:14 +0000851llvm::Constant *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000852CodeGenModule::GetOrCreateLLVMFunction(StringRef MangledName,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000853 llvm::Type *Ty,
John McCallf85e1932011-06-15 23:02:42 +0000854 GlobalDecl D, bool ForVTable,
855 llvm::Attributes ExtraAttrs) {
Chris Lattner0558e792009-03-21 09:25:43 +0000856 // Lookup the entry, lazily creating it if necessary.
John McCallf746aa62010-03-19 23:29:14 +0000857 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner0558e792009-03-21 09:25:43 +0000858 if (Entry) {
Rafael Espindola6a836702010-03-04 18:17:24 +0000859 if (WeakRefReferences.count(Entry)) {
860 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl());
861 if (FD && !FD->hasAttr<WeakAttr>())
Anders Carlsson7270ee42010-03-23 04:31:31 +0000862 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola6a836702010-03-04 18:17:24 +0000863
864 WeakRefReferences.erase(Entry);
865 }
866
Chris Lattner0558e792009-03-21 09:25:43 +0000867 if (Entry->getType()->getElementType() == Ty)
868 return Entry;
Mike Stump1eb44332009-09-09 15:08:12 +0000869
Chris Lattner0558e792009-03-21 09:25:43 +0000870 // Make sure the result is of the correct type.
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000871 return llvm::ConstantExpr::getBitCast(Entry, Ty->getPointerTo());
Chris Lattner0558e792009-03-21 09:25:43 +0000872 }
Mike Stump1eb44332009-09-09 15:08:12 +0000873
Eli Friedman654ad402009-11-09 05:07:37 +0000874 // This function doesn't have a complete type (for example, the return
875 // type is an incomplete struct). Use a fake type instead, and make
876 // sure not to try to set attributes.
877 bool IsIncompleteFunction = false;
John McCall784f2112010-04-28 00:00:30 +0000878
Chris Lattner2acc6e32011-07-18 04:24:23 +0000879 llvm::FunctionType *FTy;
John McCall784f2112010-04-28 00:00:30 +0000880 if (isa<llvm::FunctionType>(Ty)) {
881 FTy = cast<llvm::FunctionType>(Ty);
882 } else {
John McCall0774cb82011-05-15 01:53:33 +0000883 FTy = llvm::FunctionType::get(VoidTy, false);
Eli Friedman654ad402009-11-09 05:07:37 +0000884 IsIncompleteFunction = true;
885 }
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000886
John McCall784f2112010-04-28 00:00:30 +0000887 llvm::Function *F = llvm::Function::Create(FTy,
Eli Friedman654ad402009-11-09 05:07:37 +0000888 llvm::Function::ExternalLinkage,
John McCallf746aa62010-03-19 23:29:14 +0000889 MangledName, &getModule());
890 assert(F->getName() == MangledName && "name was uniqued!");
Eli Friedman654ad402009-11-09 05:07:37 +0000891 if (D.getDecl())
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000892 SetFunctionAttributes(D, F, IsIncompleteFunction);
John McCallf85e1932011-06-15 23:02:42 +0000893 if (ExtraAttrs != llvm::Attribute::None)
894 F->addFnAttr(ExtraAttrs);
Eli Friedman654ad402009-11-09 05:07:37 +0000895
Chris Lattner67b00522009-03-21 09:44:56 +0000896 // This is the first use or definition of a mangled name. If there is a
897 // deferred decl with this name, remember that we need to emit it at the end
898 // of the file.
John McCallf746aa62010-03-19 23:29:14 +0000899 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner67b00522009-03-21 09:44:56 +0000900 if (DDI != DeferredDecls.end()) {
901 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
902 // list, and remove it from DeferredDecls (since we don't need it anymore).
903 DeferredDeclsToEmit.push_back(DDI->second);
904 DeferredDecls.erase(DDI);
John McCallbfdcdc82010-12-15 04:00:32 +0000905
906 // Otherwise, there are cases we have to worry about where we're
907 // using a declaration for which we must emit a definition but where
908 // we might not find a top-level definition:
909 // - member functions defined inline in their classes
910 // - friend functions defined inline in some class
911 // - special member functions with implicit definitions
912 // If we ever change our AST traversal to walk into class methods,
913 // this will be unnecessary.
Anders Carlsson1faa89f2011-02-05 04:35:53 +0000914 //
915 // We also don't emit a definition for a function if it's going to be an entry
916 // in a vtable, unless it's already marked as used.
Rafael Espindola01de7a42011-02-03 06:30:58 +0000917 } else if (getLangOptions().CPlusPlus && D.getDecl()) {
John McCallbfdcdc82010-12-15 04:00:32 +0000918 // Look for a declaration that's lexically in a record.
919 const FunctionDecl *FD = cast<FunctionDecl>(D.getDecl());
920 do {
921 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
Anders Carlsson1faa89f2011-02-05 04:35:53 +0000922 if (FD->isImplicit() && !ForVTable) {
John McCallbfdcdc82010-12-15 04:00:32 +0000923 assert(FD->isUsed() && "Sema didn't mark implicit function as used!");
Douglas Gregora29bf412011-02-09 02:03:05 +0000924 DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
John McCallbfdcdc82010-12-15 04:00:32 +0000925 break;
Sean Hunt10620eb2011-05-06 20:44:56 +0000926 } else if (FD->doesThisDeclarationHaveABody()) {
Douglas Gregora29bf412011-02-09 02:03:05 +0000927 DeferredDeclsToEmit.push_back(D.getWithDecl(FD));
John McCallbfdcdc82010-12-15 04:00:32 +0000928 break;
929 }
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +0000930 }
John McCallbfdcdc82010-12-15 04:00:32 +0000931 FD = FD->getPreviousDeclaration();
932 } while (FD);
Chris Lattner67b00522009-03-21 09:44:56 +0000933 }
Mike Stump1eb44332009-09-09 15:08:12 +0000934
John McCall784f2112010-04-28 00:00:30 +0000935 // Make sure the result is of the requested type.
936 if (!IsIncompleteFunction) {
937 assert(F->getType()->getElementType() == Ty);
938 return F;
939 }
940
Chris Lattner9cbe4f02011-07-09 17:41:47 +0000941 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
John McCall784f2112010-04-28 00:00:30 +0000942 return llvm::ConstantExpr::getBitCast(F, PTy);
Chris Lattner0558e792009-03-21 09:25:43 +0000943}
944
Chris Lattner74391b42009-03-22 21:03:39 +0000945/// GetAddrOfFunction - Return the address of the given function. If Ty is
946/// non-null, then this function will use the specified type if it has to
947/// create it (this occurs when we see a definition of the function).
Chris Lattnerb4880ba2009-05-12 21:21:08 +0000948llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000949 llvm::Type *Ty,
Anders Carlsson1faa89f2011-02-05 04:35:53 +0000950 bool ForVTable) {
Chris Lattner74391b42009-03-22 21:03:39 +0000951 // If there was no specific requested type, just convert it now.
952 if (!Ty)
Anders Carlsson4a6835e2009-09-10 23:38:47 +0000953 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000954
Chris Lattner5f9e2722011-07-23 10:55:15 +0000955 StringRef MangledName = getMangledName(GD);
Anders Carlsson1faa89f2011-02-05 04:35:53 +0000956 return GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable);
Chris Lattner74391b42009-03-22 21:03:39 +0000957}
Eli Friedman77ba7082008-05-30 19:50:47 +0000958
Chris Lattner74391b42009-03-22 21:03:39 +0000959/// CreateRuntimeFunction - Create a new runtime function with the specified
960/// type and name.
961llvm::Constant *
Chris Lattner2acc6e32011-07-18 04:24:23 +0000962CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy,
Chris Lattner5f9e2722011-07-23 10:55:15 +0000963 StringRef Name,
John McCallf85e1932011-06-15 23:02:42 +0000964 llvm::Attributes ExtraAttrs) {
965 return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
966 ExtraAttrs);
Chris Lattner74391b42009-03-22 21:03:39 +0000967}
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000968
Douglas Gregorda550742011-05-07 22:06:45 +0000969static bool DeclIsConstantGlobal(ASTContext &Context, const VarDecl *D,
970 bool ConstantInit) {
John McCall88786862010-02-08 21:46:50 +0000971 if (!D->getType().isConstant(Context) && !D->getType()->isReferenceType())
Eli Friedman20e098b2009-12-11 21:23:03 +0000972 return false;
Douglas Gregorda550742011-05-07 22:06:45 +0000973
974 if (Context.getLangOptions().CPlusPlus) {
975 if (const RecordType *Record
976 = Context.getBaseElementType(D->getType())->getAs<RecordType>())
Douglas Gregor2bb11012011-05-13 01:05:07 +0000977 return ConstantInit &&
978 cast<CXXRecordDecl>(Record->getDecl())->isPOD() &&
979 !cast<CXXRecordDecl>(Record->getDecl())->hasMutableFields();
Eli Friedman20e098b2009-12-11 21:23:03 +0000980 }
Douglas Gregorda550742011-05-07 22:06:45 +0000981
Eli Friedman20e098b2009-12-11 21:23:03 +0000982 return true;
983}
984
Chris Lattner74391b42009-03-22 21:03:39 +0000985/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
986/// create and return an llvm GlobalVariable with the specified type. If there
987/// is something in the module with the specified name, return it potentially
988/// bitcasted to the right type.
989///
990/// If D is non-null, it specifies a decl that correspond to this. This is used
991/// to set the attributes on the global when it is first created.
John McCallf746aa62010-03-19 23:29:14 +0000992llvm::Constant *
Chris Lattner5f9e2722011-07-23 10:55:15 +0000993CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName,
Chris Lattner2acc6e32011-07-18 04:24:23 +0000994 llvm::PointerType *Ty,
Rafael Espindolac532b502011-01-18 21:07:57 +0000995 const VarDecl *D,
996 bool UnnamedAddr) {
Daniel Dunbar3c827a72008-08-05 23:31:02 +0000997 // Lookup the entry, lazily creating it if necessary.
John McCallf746aa62010-03-19 23:29:14 +0000998 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner99b53612009-03-21 08:03:33 +0000999 if (Entry) {
Rafael Espindola6a836702010-03-04 18:17:24 +00001000 if (WeakRefReferences.count(Entry)) {
1001 if (D && !D->hasAttr<WeakAttr>())
Anders Carlsson7270ee42010-03-23 04:31:31 +00001002 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola6a836702010-03-04 18:17:24 +00001003
1004 WeakRefReferences.erase(Entry);
1005 }
1006
Rafael Espindolac532b502011-01-18 21:07:57 +00001007 if (UnnamedAddr)
1008 Entry->setUnnamedAddr(true);
1009
Chris Lattner74391b42009-03-22 21:03:39 +00001010 if (Entry->getType() == Ty)
Chris Lattner570585c2009-03-21 09:16:30 +00001011 return Entry;
Mike Stump1eb44332009-09-09 15:08:12 +00001012
Chris Lattner99b53612009-03-21 08:03:33 +00001013 // Make sure the result is of the correct type.
Owen Anderson3c4972d2009-07-29 18:54:39 +00001014 return llvm::ConstantExpr::getBitCast(Entry, Ty);
Daniel Dunbar49988882009-01-13 02:25:00 +00001015 }
Mike Stump1eb44332009-09-09 15:08:12 +00001016
Chris Lattner67b00522009-03-21 09:44:56 +00001017 // This is the first use or definition of a mangled name. If there is a
1018 // deferred decl with this name, remember that we need to emit it at the end
1019 // of the file.
John McCallf746aa62010-03-19 23:29:14 +00001020 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner67b00522009-03-21 09:44:56 +00001021 if (DDI != DeferredDecls.end()) {
1022 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
1023 // list, and remove it from DeferredDecls (since we don't need it anymore).
1024 DeferredDeclsToEmit.push_back(DDI->second);
1025 DeferredDecls.erase(DDI);
1026 }
Mike Stump1eb44332009-09-09 15:08:12 +00001027
1028 llvm::GlobalVariable *GV =
1029 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
Chris Lattner99b53612009-03-21 08:03:33 +00001030 llvm::GlobalValue::ExternalLinkage,
John McCallf746aa62010-03-19 23:29:14 +00001031 0, MangledName, 0,
Eli Friedman56ebe502009-04-19 21:05:03 +00001032 false, Ty->getAddressSpace());
Chris Lattner99b53612009-03-21 08:03:33 +00001033
1034 // Handle things which are present even on external declarations.
Chris Lattner74391b42009-03-22 21:03:39 +00001035 if (D) {
Mike Stumpf5408fe2009-05-16 07:57:57 +00001036 // FIXME: This code is overly simple and should be merged with other global
1037 // handling.
Douglas Gregorda550742011-05-07 22:06:45 +00001038 GV->setConstant(DeclIsConstantGlobal(Context, D, false));
Chris Lattner99b53612009-03-21 08:03:33 +00001039
John McCall110e8e52010-10-29 22:22:43 +00001040 // Set linkage and visibility in case we never see a definition.
John McCallaf146032010-10-30 11:50:40 +00001041 NamedDecl::LinkageInfo LV = D->getLinkageAndVisibility();
1042 if (LV.linkage() != ExternalLinkage) {
John McCall15e310a2011-02-19 02:53:41 +00001043 // Don't set internal linkage on declarations.
John McCall110e8e52010-10-29 22:22:43 +00001044 } else {
1045 if (D->hasAttr<DLLImportAttr>())
1046 GV->setLinkage(llvm::GlobalValue::DLLImportLinkage);
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001047 else if (D->hasAttr<WeakAttr>() || D->isWeakImported())
John McCall110e8e52010-10-29 22:22:43 +00001048 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Chris Lattner99b53612009-03-21 08:03:33 +00001049
John McCallaf146032010-10-30 11:50:40 +00001050 // Set visibility on a declaration only if it's explicit.
1051 if (LV.visibilityExplicit())
1052 GV->setVisibility(GetLLVMVisibility(LV.visibility()));
John McCall110e8e52010-10-29 22:22:43 +00001053 }
Eli Friedman56ebe502009-04-19 21:05:03 +00001054
1055 GV->setThreadLocal(D->isThreadSpecified());
Chris Lattner74391b42009-03-22 21:03:39 +00001056 }
Mike Stump1eb44332009-09-09 15:08:12 +00001057
John McCallf746aa62010-03-19 23:29:14 +00001058 return GV;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001059}
1060
Chris Lattner74391b42009-03-22 21:03:39 +00001061
Anders Carlsson3bd62022011-01-29 18:20:20 +00001062llvm::GlobalVariable *
Chris Lattner5f9e2722011-07-23 10:55:15 +00001063CodeGenModule::CreateOrReplaceCXXRuntimeVariable(StringRef Name,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001064 llvm::Type *Ty,
Anders Carlsson3bd62022011-01-29 18:20:20 +00001065 llvm::GlobalValue::LinkageTypes Linkage) {
1066 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
1067 llvm::GlobalVariable *OldGV = 0;
1068
1069
1070 if (GV) {
1071 // Check if the variable has the right type.
1072 if (GV->getType()->getElementType() == Ty)
1073 return GV;
1074
1075 // Because C++ name mangling, the only way we can end up with an already
1076 // existing global with the same name is if it has been declared extern "C".
Anders Carlsson96eaf292011-01-29 18:25:07 +00001077 assert(GV->isDeclaration() && "Declaration has wrong type!");
Anders Carlsson3bd62022011-01-29 18:20:20 +00001078 OldGV = GV;
1079 }
1080
1081 // Create a new variable.
1082 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
1083 Linkage, 0, Name);
1084
1085 if (OldGV) {
1086 // Replace occurrences of the old variable if needed.
1087 GV->takeName(OldGV);
1088
1089 if (!OldGV->use_empty()) {
1090 llvm::Constant *NewPtrForOldDecl =
1091 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
1092 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
1093 }
1094
1095 OldGV->eraseFromParent();
1096 }
1097
1098 return GV;
1099}
1100
Chris Lattner74391b42009-03-22 21:03:39 +00001101/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
1102/// given global variable. If Ty is non-null and if the global doesn't exist,
1103/// then it will be greated with the specified type instead of whatever the
1104/// normal requested type would be.
1105llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
Chris Lattner2acc6e32011-07-18 04:24:23 +00001106 llvm::Type *Ty) {
Chris Lattner74391b42009-03-22 21:03:39 +00001107 assert(D->hasGlobalStorage() && "Not a global variable");
1108 QualType ASTTy = D->getType();
1109 if (Ty == 0)
1110 Ty = getTypes().ConvertTypeForMem(ASTTy);
Mike Stump1eb44332009-09-09 15:08:12 +00001111
Chris Lattner2acc6e32011-07-18 04:24:23 +00001112 llvm::PointerType *PTy =
Peter Collingbourne207f4d82011-03-18 22:38:29 +00001113 llvm::PointerType::get(Ty, getContext().getTargetAddressSpace(ASTTy));
John McCallf746aa62010-03-19 23:29:14 +00001114
Chris Lattner5f9e2722011-07-23 10:55:15 +00001115 StringRef MangledName = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +00001116 return GetOrCreateLLVMGlobal(MangledName, PTy, D);
Chris Lattner74391b42009-03-22 21:03:39 +00001117}
1118
1119/// CreateRuntimeVariable - Create a new runtime global variable with the
1120/// specified type and name.
1121llvm::Constant *
Chris Lattner2acc6e32011-07-18 04:24:23 +00001122CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
Chris Lattner5f9e2722011-07-23 10:55:15 +00001123 StringRef Name) {
John McCall1de4d4e2011-04-07 08:22:57 +00001124 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0,
Rafael Espindolac532b502011-01-18 21:07:57 +00001125 true);
Chris Lattner74391b42009-03-22 21:03:39 +00001126}
1127
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001128void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1129 assert(!D->getInit() && "Cannot emit definite definitions here!");
1130
Douglas Gregor7520bd12009-04-21 19:28:58 +00001131 if (MayDeferGeneration(D)) {
1132 // If we have not seen a reference to this variable yet, place it
1133 // into the deferred declarations table to be emitted if needed
1134 // later.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001135 StringRef MangledName = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +00001136 if (!GetGlobalValue(MangledName)) {
Anders Carlsson555b4bb2009-09-10 23:43:36 +00001137 DeferredDecls[MangledName] = D;
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001138 return;
Douglas Gregor7520bd12009-04-21 19:28:58 +00001139 }
1140 }
1141
1142 // The tentative definition is the only definition.
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001143 EmitGlobalVarDefinition(D);
1144}
1145
Douglas Gregor6fb745b2010-05-13 16:44:06 +00001146void CodeGenModule::EmitVTable(CXXRecordDecl *Class, bool DefinitionRequired) {
1147 if (DefinitionRequired)
1148 getVTables().GenerateClassData(getVTableLinkage(Class), Class);
1149}
1150
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001151llvm::GlobalVariable::LinkageTypes
Anders Carlsson046c2942010-04-17 20:15:18 +00001152CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
Eli Friedmancb5d2d02011-06-10 21:53:06 +00001153 if (RD->getLinkage() != ExternalLinkage)
Douglas Gregordffb8012010-01-06 22:00:56 +00001154 return llvm::GlobalVariable::InternalLinkage;
1155
1156 if (const CXXMethodDecl *KeyFunction
1157 = RD->getASTContext().getKeyFunction(RD)) {
1158 // If this class has a key function, use that to determine the linkage of
1159 // the vtable.
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001160 const FunctionDecl *Def = 0;
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +00001161 if (KeyFunction->hasBody(Def))
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001162 KeyFunction = cast<CXXMethodDecl>(Def);
Douglas Gregordffb8012010-01-06 22:00:56 +00001163
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001164 switch (KeyFunction->getTemplateSpecializationKind()) {
1165 case TSK_Undeclared:
1166 case TSK_ExplicitSpecialization:
Anders Carlsson6d7f8472011-01-30 20:45:54 +00001167 // When compiling with optimizations turned on, we emit all vtables,
1168 // even if the key function is not defined in the current translation
1169 // unit. If this is the case, use available_externally linkage.
1170 if (!Def && CodeGenOpts.OptimizationLevel)
1171 return llvm::GlobalVariable::AvailableExternallyLinkage;
1172
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001173 if (KeyFunction->isInlined())
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001174 return !Context.getLangOptions().AppleKext ?
1175 llvm::GlobalVariable::LinkOnceODRLinkage :
1176 llvm::Function::InternalLinkage;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001177
1178 return llvm::GlobalVariable::ExternalLinkage;
1179
1180 case TSK_ImplicitInstantiation:
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001181 return !Context.getLangOptions().AppleKext ?
1182 llvm::GlobalVariable::LinkOnceODRLinkage :
1183 llvm::Function::InternalLinkage;
Anders Carlssonf502d932011-01-24 00:46:19 +00001184
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001185 case TSK_ExplicitInstantiationDefinition:
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001186 return !Context.getLangOptions().AppleKext ?
1187 llvm::GlobalVariable::WeakODRLinkage :
1188 llvm::Function::InternalLinkage;
Anders Carlssonf502d932011-01-24 00:46:19 +00001189
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001190 case TSK_ExplicitInstantiationDeclaration:
1191 // FIXME: Use available_externally linkage. However, this currently
1192 // breaks LLVM's build due to undefined symbols.
1193 // return llvm::GlobalVariable::AvailableExternallyLinkage;
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001194 return !Context.getLangOptions().AppleKext ?
1195 llvm::GlobalVariable::LinkOnceODRLinkage :
1196 llvm::Function::InternalLinkage;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001197 }
Douglas Gregordffb8012010-01-06 22:00:56 +00001198 }
1199
Fariborz Jahanian53bad4e2011-02-04 00:32:39 +00001200 if (Context.getLangOptions().AppleKext)
1201 return llvm::Function::InternalLinkage;
1202
Douglas Gregordffb8012010-01-06 22:00:56 +00001203 switch (RD->getTemplateSpecializationKind()) {
1204 case TSK_Undeclared:
1205 case TSK_ExplicitSpecialization:
1206 case TSK_ImplicitInstantiation:
Douglas Gregordffb8012010-01-06 22:00:56 +00001207 // FIXME: Use available_externally linkage. However, this currently
1208 // breaks LLVM's build due to undefined symbols.
1209 // return llvm::GlobalVariable::AvailableExternallyLinkage;
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001210 case TSK_ExplicitInstantiationDeclaration:
Fariborz Jahanian53bad4e2011-02-04 00:32:39 +00001211 return llvm::GlobalVariable::LinkOnceODRLinkage;
Fariborz Jahanian142f9e92011-02-04 00:01:24 +00001212
1213 case TSK_ExplicitInstantiationDefinition:
Fariborz Jahanian53bad4e2011-02-04 00:32:39 +00001214 return llvm::GlobalVariable::WeakODRLinkage;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001215 }
1216
1217 // Silence GCC warning.
Fariborz Jahanian53bad4e2011-02-04 00:32:39 +00001218 return llvm::GlobalVariable::LinkOnceODRLinkage;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001219}
1220
Chris Lattner2acc6e32011-07-18 04:24:23 +00001221CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
Ken Dyck06f486e2011-01-18 02:01:14 +00001222 return Context.toCharUnitsFromBits(
1223 TheTargetData.getTypeStoreSizeInBits(Ty));
Ken Dyck687cc4a2010-01-26 13:48:07 +00001224}
1225
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001226void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
Chris Lattner8f32f712007-07-14 00:23:28 +00001227 llvm::Constant *Init = 0;
Eli Friedman77ba7082008-05-30 19:50:47 +00001228 QualType ASTTy = D->getType();
Eli Friedman6c6bda32010-01-08 00:50:11 +00001229 bool NonConstInit = false;
Mike Stump1eb44332009-09-09 15:08:12 +00001230
Sebastian Redl31310a22010-02-01 20:16:42 +00001231 const Expr *InitExpr = D->getAnyInitializer();
Anders Carlsson3bb92692010-01-26 17:43:42 +00001232
1233 if (!InitExpr) {
Eli Friedmancd5f4aa2008-05-30 20:39:54 +00001234 // This is a tentative definition; tentative definitions are
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001235 // implicitly initialized with { 0 }.
1236 //
1237 // Note that tentative definitions are only emitted at the end of
1238 // a translation unit, so they should never have incomplete
1239 // type. In addition, EmitTentativeDefinition makes sure that we
1240 // never attempt to emit a tentative definition if a real one
1241 // exists. A use may still exists, however, so we still may need
1242 // to do a RAUW.
1243 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
Anders Carlssonb0d0ea02009-08-02 21:18:22 +00001244 Init = EmitNullConstant(D->getType());
Eli Friedman77ba7082008-05-30 19:50:47 +00001245 } else {
Douglas Gregorc446d182010-05-05 20:15:55 +00001246 Init = EmitConstantExpr(InitExpr, D->getType());
Eli Friedman6e656f42009-02-20 01:18:21 +00001247 if (!Init) {
Anders Carlsson3bb92692010-01-26 17:43:42 +00001248 QualType T = InitExpr->getType();
Douglas Gregorc446d182010-05-05 20:15:55 +00001249 if (D->getType()->isReferenceType())
1250 T = D->getType();
1251
Anders Carlsson89ed31d2009-08-08 23:24:23 +00001252 if (getLangOptions().CPlusPlus) {
Anders Carlsson89ed31d2009-08-08 23:24:23 +00001253 Init = EmitNullConstant(T);
Eli Friedman6c6bda32010-01-08 00:50:11 +00001254 NonConstInit = true;
Anders Carlsson89ed31d2009-08-08 23:24:23 +00001255 } else {
1256 ErrorUnsupported(D, "static initializer");
1257 Init = llvm::UndefValue::get(getTypes().ConvertType(T));
1258 }
John McCallbf40cb52010-07-15 23:40:35 +00001259 } else {
1260 // We don't need an initializer, so remove the entry for the delayed
1261 // initializer position (just in case this entry was delayed).
1262 if (getLangOptions().CPlusPlus)
1263 DelayedCXXInitPosition.erase(D);
Eli Friedman6e656f42009-02-20 01:18:21 +00001264 }
Eli Friedman77ba7082008-05-30 19:50:47 +00001265 }
Eli Friedman77ba7082008-05-30 19:50:47 +00001266
Chris Lattner2acc6e32011-07-18 04:24:23 +00001267 llvm::Type* InitType = Init->getType();
Chris Lattner570585c2009-03-21 09:16:30 +00001268 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
Mike Stump1eb44332009-09-09 15:08:12 +00001269
Chris Lattner570585c2009-03-21 09:16:30 +00001270 // Strip off a bitcast if we got one back.
1271 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
Chris Lattner9d4a15f2009-07-16 16:48:25 +00001272 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
1273 // all zero index gep.
1274 CE->getOpcode() == llvm::Instruction::GetElementPtr);
Chris Lattner570585c2009-03-21 09:16:30 +00001275 Entry = CE->getOperand(0);
1276 }
Mike Stump1eb44332009-09-09 15:08:12 +00001277
Chris Lattner570585c2009-03-21 09:16:30 +00001278 // Entry is now either a Function or GlobalVariable.
1279 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00001280
Chris Lattner570585c2009-03-21 09:16:30 +00001281 // We have a definition after a declaration with the wrong type.
1282 // We must make a new GlobalVariable* and update everything that used OldGV
1283 // (a declaration or tentative definition) with the new GlobalVariable*
1284 // (which will be a definition).
1285 //
1286 // This happens if there is a prototype for a global (e.g.
1287 // "extern int x[];") and then a definition of a different type (e.g.
1288 // "int x[10];"). This also happens when an initializer has a different type
1289 // from the type of the global (this happens with unions).
Chris Lattner570585c2009-03-21 09:16:30 +00001290 if (GV == 0 ||
1291 GV->getType()->getElementType() != InitType ||
Peter Collingbourne207f4d82011-03-18 22:38:29 +00001292 GV->getType()->getAddressSpace() !=
1293 getContext().getTargetAddressSpace(ASTTy)) {
Mike Stump1eb44332009-09-09 15:08:12 +00001294
John McCallf746aa62010-03-19 23:29:14 +00001295 // Move the old entry aside so that we'll create a new one.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001296 Entry->setName(StringRef());
Daniel Dunbar232350d2009-02-19 05:36:41 +00001297
Chris Lattner570585c2009-03-21 09:16:30 +00001298 // Make a new global with the correct type, this is now guaranteed to work.
1299 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
Chris Lattner0558e792009-03-21 09:25:43 +00001300
Eli Friedman77ba7082008-05-30 19:50:47 +00001301 // Replace all uses of the old global with the new global
Mike Stump1eb44332009-09-09 15:08:12 +00001302 llvm::Constant *NewPtrForOldDecl =
Owen Anderson3c4972d2009-07-29 18:54:39 +00001303 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
Chris Lattner570585c2009-03-21 09:16:30 +00001304 Entry->replaceAllUsesWith(NewPtrForOldDecl);
Eli Friedman77ba7082008-05-30 19:50:47 +00001305
1306 // Erase the old global, since it is no longer used.
Chris Lattner570585c2009-03-21 09:16:30 +00001307 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
Chris Lattner8f32f712007-07-14 00:23:28 +00001308 }
Devang Patel8e53e722007-10-26 16:31:40 +00001309
Julien Lerouge77f68bb2011-09-09 22:41:49 +00001310 if (D->hasAttr<AnnotateAttr>())
1311 AddGlobalAnnotations(D, GV);
Nate Begeman8bd4afe2008-04-19 04:17:09 +00001312
Chris Lattner88a69ad2007-07-13 05:13:43 +00001313 GV->setInitializer(Init);
Chris Lattnere78b86f2009-08-05 05:20:29 +00001314
1315 // If it is safe to mark the global 'constant', do so now.
1316 GV->setConstant(false);
Douglas Gregorda550742011-05-07 22:06:45 +00001317 if (!NonConstInit && DeclIsConstantGlobal(Context, D, true))
Chris Lattnere78b86f2009-08-05 05:20:29 +00001318 GV->setConstant(true);
Mike Stump1eb44332009-09-09 15:08:12 +00001319
Ken Dyck8b752f12010-01-27 17:10:57 +00001320 GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001321
Chris Lattner88a69ad2007-07-13 05:13:43 +00001322 // Set the llvm linkage type as appropriate.
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001323 llvm::GlobalValue::LinkageTypes Linkage =
1324 GetLLVMLinkageVarDefinition(D, GV);
1325 GV->setLinkage(Linkage);
1326 if (Linkage == llvm::GlobalVariable::CommonLinkage)
Chris Lattnere78b86f2009-08-05 05:20:29 +00001327 // common vars aren't constant even if declared const.
1328 GV->setConstant(false);
Daniel Dunbar7e714cd2009-04-10 20:26:50 +00001329
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001330 SetCommonAttributes(D, GV);
Daniel Dunbar04d40782009-04-14 06:00:08 +00001331
John McCall3030eb82010-11-06 09:44:32 +00001332 // Emit the initializer function if necessary.
1333 if (NonConstInit)
1334 EmitCXXGlobalVarDeclInitFunc(D, GV);
1335
Sanjiv Gupta686226b2008-06-05 08:59:10 +00001336 // Emit global variable debug information.
Devang Patelaa112892011-03-07 18:45:56 +00001337 if (CGDebugInfo *DI = getModuleDebugInfo()) {
Daniel Dunbar66031a52008-10-17 16:15:48 +00001338 DI->setLocation(D->getLocation());
Sanjiv Gupta686226b2008-06-05 08:59:10 +00001339 DI->EmitGlobalVariable(GV, D);
1340 }
Chris Lattner88a69ad2007-07-13 05:13:43 +00001341}
Reid Spencer5f016e22007-07-11 17:01:13 +00001342
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001343llvm::GlobalValue::LinkageTypes
1344CodeGenModule::GetLLVMLinkageVarDefinition(const VarDecl *D,
1345 llvm::GlobalVariable *GV) {
1346 GVALinkage Linkage = getContext().GetGVALinkageForVariable(D);
1347 if (Linkage == GVA_Internal)
1348 return llvm::Function::InternalLinkage;
1349 else if (D->hasAttr<DLLImportAttr>())
1350 return llvm::Function::DLLImportLinkage;
1351 else if (D->hasAttr<DLLExportAttr>())
1352 return llvm::Function::DLLExportLinkage;
1353 else if (D->hasAttr<WeakAttr>()) {
1354 if (GV->isConstant())
1355 return llvm::GlobalVariable::WeakODRLinkage;
1356 else
1357 return llvm::GlobalVariable::WeakAnyLinkage;
1358 } else if (Linkage == GVA_TemplateInstantiation ||
1359 Linkage == GVA_ExplicitTemplateInstantiation)
John McCall99ace162011-04-12 01:46:54 +00001360 return llvm::GlobalVariable::WeakODRLinkage;
Eric Christophera6cf1e72010-12-02 02:45:55 +00001361 else if (!getLangOptions().CPlusPlus &&
1362 ((!CodeGenOpts.NoCommon && !D->getAttr<NoCommonAttr>()) ||
1363 D->getAttr<CommonAttr>()) &&
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001364 !D->hasExternalStorage() && !D->getInit() &&
Fariborz Jahanianab27d6e2011-06-20 17:50:03 +00001365 !D->getAttr<SectionAttr>() && !D->isThreadSpecified() &&
1366 !D->getAttr<WeakImportAttr>()) {
Fariborz Jahanian354e7122010-10-27 16:21:54 +00001367 // Thread local vars aren't considered common linkage.
1368 return llvm::GlobalVariable::CommonLinkage;
1369 }
1370 return llvm::GlobalVariable::ExternalLinkage;
1371}
1372
Chris Lattnerbdb01322009-05-05 06:16:31 +00001373/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
1374/// implement a function with no prototype, e.g. "int foo() {}". If there are
1375/// existing call uses of the old function in the module, this adjusts them to
1376/// call the new function directly.
1377///
1378/// This is not just a cleanup: the always_inline pass requires direct calls to
1379/// functions to be able to inline them. If there is a bitcast in the way, it
1380/// won't inline them. Instcombine normally deletes these calls, but it isn't
1381/// run at -O0.
1382static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
1383 llvm::Function *NewFn) {
1384 // If we're redefining a global as a function, don't transform it.
1385 llvm::Function *OldFn = dyn_cast<llvm::Function>(Old);
1386 if (OldFn == 0) return;
Mike Stump1eb44332009-09-09 15:08:12 +00001387
Chris Lattner2acc6e32011-07-18 04:24:23 +00001388 llvm::Type *NewRetTy = NewFn->getReturnType();
Chris Lattner5f9e2722011-07-23 10:55:15 +00001389 SmallVector<llvm::Value*, 4> ArgList;
Chris Lattnerbdb01322009-05-05 06:16:31 +00001390
1391 for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end();
Benjamin Kramerdbf02bc2010-04-10 11:02:40 +00001392 UI != E; ) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00001393 // TODO: Do invokes ever occur in C code? If so, we should handle them too.
Benjamin Kramerdbf02bc2010-04-10 11:02:40 +00001394 llvm::Value::use_iterator I = UI++; // Increment before the CI is erased.
1395 llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*I);
Gabor Greif8670cd32010-07-28 09:19:33 +00001396 if (!CI) continue; // FIXME: when we allow Invoke, just do CallSite CS(*I)
Gabor Greif35db3b92010-04-10 03:45:50 +00001397 llvm::CallSite CS(CI);
Benjamin Kramerdbf02bc2010-04-10 11:02:40 +00001398 if (!CI || !CS.isCallee(I)) continue;
Mike Stump1eb44332009-09-09 15:08:12 +00001399
Chris Lattnerbdb01322009-05-05 06:16:31 +00001400 // If the return types don't match exactly, and if the call isn't dead, then
1401 // we can't transform this call.
1402 if (CI->getType() != NewRetTy && !CI->use_empty())
1403 continue;
1404
John McCall40f9c302011-08-03 00:43:55 +00001405 // Get the attribute list.
1406 llvm::SmallVector<llvm::AttributeWithIndex, 8> AttrVec;
1407 llvm::AttrListPtr AttrList = CI->getAttributes();
1408
1409 // Get any return attributes.
1410 llvm::Attributes RAttrs = AttrList.getRetAttributes();
1411
1412 // Add the return attributes.
1413 if (RAttrs)
1414 AttrVec.push_back(llvm::AttributeWithIndex::get(0, RAttrs));
1415
Chris Lattnerbdb01322009-05-05 06:16:31 +00001416 // If the function was passed too few arguments, don't transform. If extra
1417 // arguments were passed, we silently drop them. If any of the types
1418 // mismatch, we don't transform.
1419 unsigned ArgNo = 0;
1420 bool DontTransform = false;
1421 for (llvm::Function::arg_iterator AI = NewFn->arg_begin(),
1422 E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) {
Gabor Greif35db3b92010-04-10 03:45:50 +00001423 if (CS.arg_size() == ArgNo ||
1424 CS.getArgument(ArgNo)->getType() != AI->getType()) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00001425 DontTransform = true;
1426 break;
1427 }
John McCall40f9c302011-08-03 00:43:55 +00001428
1429 // Add any parameter attributes.
1430 if (llvm::Attributes PAttrs = AttrList.getParamAttributes(ArgNo + 1))
1431 AttrVec.push_back(llvm::AttributeWithIndex::get(ArgNo + 1, PAttrs));
Chris Lattnerbdb01322009-05-05 06:16:31 +00001432 }
1433 if (DontTransform)
1434 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00001435
John McCall40f9c302011-08-03 00:43:55 +00001436 if (llvm::Attributes FnAttrs = AttrList.getFnAttributes())
1437 AttrVec.push_back(llvm::AttributeWithIndex::get(~0, FnAttrs));
1438
Chris Lattnerbdb01322009-05-05 06:16:31 +00001439 // Okay, we can transform this. Create the new call instruction and copy
1440 // over the required information.
Gabor Greif6ba728d2010-04-10 02:56:12 +00001441 ArgList.append(CS.arg_begin(), CS.arg_begin() + ArgNo);
Jay Foad4c7d9f12011-07-15 08:37:34 +00001442 llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList, "", CI);
Chris Lattnerbdb01322009-05-05 06:16:31 +00001443 ArgList.clear();
Benjamin Kramerffbb15e2009-10-05 13:47:21 +00001444 if (!NewCall->getType()->isVoidTy())
Chris Lattnerbdb01322009-05-05 06:16:31 +00001445 NewCall->takeName(CI);
John McCall40f9c302011-08-03 00:43:55 +00001446 NewCall->setAttributes(llvm::AttrListPtr::get(AttrVec.begin(),
1447 AttrVec.end()));
Daniel Dunbarca6408c2009-09-12 00:59:20 +00001448 NewCall->setCallingConv(CI->getCallingConv());
Chris Lattnerbdb01322009-05-05 06:16:31 +00001449
1450 // Finally, remove the old call, replacing any uses with the new one.
Chris Lattner00549fc2009-10-14 05:49:21 +00001451 if (!CI->use_empty())
1452 CI->replaceAllUsesWith(NewCall);
Devang Patel3b122bc2009-10-13 17:02:04 +00001453
Chris Lattnerc6034632010-04-01 06:31:43 +00001454 // Copy debug location attached to CI.
1455 if (!CI->getDebugLoc().isUnknown())
1456 NewCall->setDebugLoc(CI->getDebugLoc());
Chris Lattnerbdb01322009-05-05 06:16:31 +00001457 CI->eraseFromParent();
1458 }
1459}
1460
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001461
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001462void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001463 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
John McCalld26bc762011-03-09 04:27:21 +00001464
John McCall1f6f9612011-03-09 08:12:35 +00001465 // Compute the function info and LLVM type.
John McCalld26bc762011-03-09 04:27:21 +00001466 const CGFunctionInfo &FI = getTypes().getFunctionInfo(GD);
John McCall1f6f9612011-03-09 08:12:35 +00001467 bool variadic = false;
1468 if (const FunctionProtoType *fpt = D->getType()->getAs<FunctionProtoType>())
1469 variadic = fpt->isVariadic();
Chris Lattner2acc6e32011-07-18 04:24:23 +00001470 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI, variadic);
John McCalld26bc762011-03-09 04:27:21 +00001471
Chris Lattner9fa959d2009-05-12 20:58:15 +00001472 // Get or create the prototype for the function.
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001473 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
Mike Stump1eb44332009-09-09 15:08:12 +00001474
Chris Lattner0558e792009-03-21 09:25:43 +00001475 // Strip off a bitcast if we got one back.
1476 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
1477 assert(CE->getOpcode() == llvm::Instruction::BitCast);
1478 Entry = CE->getOperand(0);
1479 }
Mike Stump1eb44332009-09-09 15:08:12 +00001480
1481
Chris Lattner0558e792009-03-21 09:25:43 +00001482 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00001483 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00001484
Daniel Dunbar42745812009-03-09 23:53:08 +00001485 // If the types mismatch then we have to rewrite the definition.
Chris Lattnerbdb01322009-05-05 06:16:31 +00001486 assert(OldFn->isDeclaration() &&
Chris Lattner0558e792009-03-21 09:25:43 +00001487 "Shouldn't replace non-declaration");
Chris Lattner34809502009-03-21 08:53:37 +00001488
Chris Lattner62b33ea2009-03-21 08:38:50 +00001489 // F is the Function* for the one with the wrong type, we must make a new
1490 // Function* and update everything that used F (a declaration) with the new
1491 // Function* (which will be a definition).
1492 //
1493 // This happens if there is a prototype for a function
1494 // (e.g. "int f()") and then a definition of a different type
John McCallf746aa62010-03-19 23:29:14 +00001495 // (e.g. "int f(int x)"). Move the old function aside so that it
1496 // doesn't interfere with GetAddrOfFunction.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001497 OldFn->setName(StringRef());
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001498 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
Mike Stump1eb44332009-09-09 15:08:12 +00001499
Chris Lattnerbdb01322009-05-05 06:16:31 +00001500 // If this is an implementation of a function without a prototype, try to
1501 // replace any existing uses of the function (which may be calls) with uses
1502 // of the new function
Chris Lattner9fa959d2009-05-12 20:58:15 +00001503 if (D->getType()->isFunctionNoProtoType()) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00001504 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
Chris Lattner9fa959d2009-05-12 20:58:15 +00001505 OldFn->removeDeadConstantUsers();
1506 }
Mike Stump1eb44332009-09-09 15:08:12 +00001507
Chris Lattner62b33ea2009-03-21 08:38:50 +00001508 // Replace uses of F with the Function we will endow with a body.
Chris Lattnerbdb01322009-05-05 06:16:31 +00001509 if (!Entry->use_empty()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001510 llvm::Constant *NewPtrForOldDecl =
Owen Anderson3c4972d2009-07-29 18:54:39 +00001511 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
Chris Lattnerbdb01322009-05-05 06:16:31 +00001512 Entry->replaceAllUsesWith(NewPtrForOldDecl);
1513 }
Mike Stump1eb44332009-09-09 15:08:12 +00001514
Chris Lattner62b33ea2009-03-21 08:38:50 +00001515 // Ok, delete the old function now, which is dead.
Chris Lattnerbdb01322009-05-05 06:16:31 +00001516 OldFn->eraseFromParent();
Mike Stump1eb44332009-09-09 15:08:12 +00001517
Chris Lattner0558e792009-03-21 09:25:43 +00001518 Entry = NewFn;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001519 }
Mike Stump1eb44332009-09-09 15:08:12 +00001520
John McCall112c9672010-11-02 21:04:24 +00001521 // We need to set linkage and visibility on the function before
1522 // generating code for it because various parts of IR generation
1523 // want to propagate this information down (e.g. to local static
1524 // declarations).
Chris Lattner0558e792009-03-21 09:25:43 +00001525 llvm::Function *Fn = cast<llvm::Function>(Entry);
John McCall8b242332010-05-25 04:30:21 +00001526 setFunctionLinkage(D, Fn);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001527
John McCall112c9672010-11-02 21:04:24 +00001528 // FIXME: this is redundant with part of SetFunctionDefinitionAttributes
Anders Carlsson0ffeaad2011-01-29 19:39:23 +00001529 setGlobalVisibility(Fn, D);
John McCall112c9672010-11-02 21:04:24 +00001530
John McCalld26bc762011-03-09 04:27:21 +00001531 CodeGenFunction(*this).GenerateCode(D, Fn, FI);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +00001532
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001533 SetFunctionDefinitionAttributes(D, Fn);
1534 SetLLVMFunctionAttributesForDefinition(D, Fn);
Mike Stump1eb44332009-09-09 15:08:12 +00001535
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001536 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
Daniel Dunbar219df662008-09-08 23:44:31 +00001537 AddGlobalCtor(Fn, CA->getPriority());
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001538 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
Daniel Dunbar219df662008-09-08 23:44:31 +00001539 AddGlobalDtor(Fn, DA->getPriority());
Julien Lerouge77f68bb2011-09-09 22:41:49 +00001540 if (D->hasAttr<AnnotateAttr>())
1541 AddGlobalAnnotations(D, Fn);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001542}
1543
John McCallf746aa62010-03-19 23:29:14 +00001544void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
1545 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001546 const AliasAttr *AA = D->getAttr<AliasAttr>();
Chris Lattnerbd532712009-03-22 21:47:11 +00001547 assert(AA && "Not an alias?");
1548
Chris Lattner5f9e2722011-07-23 10:55:15 +00001549 StringRef MangledName = getMangledName(GD);
Mike Stump1eb44332009-09-09 15:08:12 +00001550
John McCallf746aa62010-03-19 23:29:14 +00001551 // If there is a definition in the module, then it wins over the alias.
1552 // This is dubious, but allow it to be safe. Just ignore the alias.
1553 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1554 if (Entry && !Entry->isDeclaration())
1555 return;
1556
Chris Lattner2acc6e32011-07-18 04:24:23 +00001557 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
Chris Lattnerbd532712009-03-22 21:47:11 +00001558
1559 // Create a reference to the named value. This ensures that it is emitted
1560 // if a deferred decl.
1561 llvm::Constant *Aliasee;
1562 if (isa<llvm::FunctionType>(DeclTy))
Anders Carlsson1faa89f2011-02-05 04:35:53 +00001563 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl(),
1564 /*ForVTable=*/false);
Chris Lattnerbd532712009-03-22 21:47:11 +00001565 else
John McCallf746aa62010-03-19 23:29:14 +00001566 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Owen Anderson96e0fc72009-07-29 22:16:19 +00001567 llvm::PointerType::getUnqual(DeclTy), 0);
Chris Lattnerbd532712009-03-22 21:47:11 +00001568
1569 // Create the new alias itself, but don't set a name yet.
Mike Stump1eb44332009-09-09 15:08:12 +00001570 llvm::GlobalValue *GA =
Chris Lattnerbd532712009-03-22 21:47:11 +00001571 new llvm::GlobalAlias(Aliasee->getType(),
1572 llvm::Function::ExternalLinkage,
1573 "", Aliasee, &getModule());
Mike Stump1eb44332009-09-09 15:08:12 +00001574
Chris Lattnerbd532712009-03-22 21:47:11 +00001575 if (Entry) {
John McCallf746aa62010-03-19 23:29:14 +00001576 assert(Entry->isDeclaration());
1577
Chris Lattnerbd532712009-03-22 21:47:11 +00001578 // If there is a declaration in the module, then we had an extern followed
1579 // by the alias, as in:
1580 // extern int test6();
1581 // ...
1582 // int test6() __attribute__((alias("test7")));
1583 //
1584 // Remove it and replace uses of it with the alias.
John McCallf746aa62010-03-19 23:29:14 +00001585 GA->takeName(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00001586
Owen Anderson3c4972d2009-07-29 18:54:39 +00001587 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
Chris Lattnerbd532712009-03-22 21:47:11 +00001588 Entry->getType()));
Chris Lattnerbd532712009-03-22 21:47:11 +00001589 Entry->eraseFromParent();
John McCallf746aa62010-03-19 23:29:14 +00001590 } else {
Anders Carlsson9a20d552010-06-22 16:16:50 +00001591 GA->setName(MangledName);
Chris Lattnerbd532712009-03-22 21:47:11 +00001592 }
Mike Stump1eb44332009-09-09 15:08:12 +00001593
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001594 // Set attributes which are particular to an alias; this is a
1595 // specialization of the attributes which may be set on a global
1596 // variable/function.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001597 if (D->hasAttr<DLLExportAttr>()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001598 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1599 // The dllexport attribute is ignored for undefined symbols.
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +00001600 if (FD->hasBody())
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001601 GA->setLinkage(llvm::Function::DLLExportLinkage);
1602 } else {
1603 GA->setLinkage(llvm::Function::DLLExportLinkage);
1604 }
Mike Stump1eb44332009-09-09 15:08:12 +00001605 } else if (D->hasAttr<WeakAttr>() ||
Rafael Espindola11e8ce72010-02-23 22:00:30 +00001606 D->hasAttr<WeakRefAttr>() ||
Douglas Gregor0a0d2b12011-03-23 00:50:03 +00001607 D->isWeakImported()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001608 GA->setLinkage(llvm::Function::WeakAnyLinkage);
1609 }
1610
1611 SetCommonAttributes(D, GA);
Chris Lattnerbd532712009-03-22 21:47:11 +00001612}
1613
Chris Lattnerb808c952009-03-22 21:56:56 +00001614/// getBuiltinLibFunction - Given a builtin id for a function like
1615/// "__builtin_fabsf", return a Function* for "fabsf".
Daniel Dunbar34771b52009-09-14 04:33:21 +00001616llvm::Value *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD,
1617 unsigned BuiltinID) {
Douglas Gregor3e41d602009-02-13 23:20:09 +00001618 assert((Context.BuiltinInfo.isLibFunction(BuiltinID) ||
Mike Stump1eb44332009-09-09 15:08:12 +00001619 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) &&
Douglas Gregor3e41d602009-02-13 23:20:09 +00001620 "isn't a lib fn");
Mike Stump1eb44332009-09-09 15:08:12 +00001621
Douglas Gregor3e41d602009-02-13 23:20:09 +00001622 // Get the name, skip over the __builtin_ prefix (if necessary).
Chris Lattner5f9e2722011-07-23 10:55:15 +00001623 StringRef Name;
Joerg Sonnenberger4fe497d2011-05-13 21:12:10 +00001624 GlobalDecl D(FD);
1625
1626 // If the builtin has been declared explicitly with an assembler label,
1627 // use the mangled name. This differs from the plain label on platforms
1628 // that prefix labels.
Joerg Sonnenberger62c296e2011-05-13 22:58:37 +00001629 if (FD->hasAttr<AsmLabelAttr>())
Joerg Sonnenberger4fe497d2011-05-13 21:12:10 +00001630 Name = getMangledName(D);
1631 else if (Context.BuiltinInfo.isLibFunction(BuiltinID))
1632 Name = Context.BuiltinInfo.GetName(BuiltinID) + 10;
1633 else
1634 Name = Context.BuiltinInfo.GetName(BuiltinID);
1635
Mike Stump1eb44332009-09-09 15:08:12 +00001636
Chris Lattner2acc6e32011-07-18 04:24:23 +00001637 llvm::FunctionType *Ty =
Eli Friedman386ca782009-12-09 03:05:59 +00001638 cast<llvm::FunctionType>(getTypes().ConvertType(FD->getType()));
Chris Lattnerbef20ac2007-08-31 04:31:45 +00001639
Joerg Sonnenberger4fe497d2011-05-13 21:12:10 +00001640 return GetOrCreateLLVMFunction(Name, Ty, D, /*ForVTable=*/false);
Chris Lattnerbef20ac2007-08-31 04:31:45 +00001641}
1642
Benjamin Kramer8dd55a32011-07-14 17:45:50 +00001643llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
Chris Lattner2d3ba4f2011-07-23 17:14:25 +00001644 ArrayRef<llvm::Type*> Tys) {
Jay Foaddf983a82011-07-12 14:06:48 +00001645 return llvm::Intrinsic::getDeclaration(&getModule(), (llvm::Intrinsic::ID)IID,
Benjamin Kramer8dd55a32011-07-14 17:45:50 +00001646 Tys);
Chris Lattner7acda7c2007-12-18 00:25:38 +00001647}
Chris Lattnerbef20ac2007-08-31 04:31:45 +00001648
Daniel Dunbar1d552912009-07-23 22:52:48 +00001649static llvm::StringMapEntry<llvm::Constant*> &
1650GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
1651 const StringLiteral *Literal,
Daniel Dunbar70ee9752009-07-23 23:41:22 +00001652 bool TargetIsLSB,
Daniel Dunbar1d552912009-07-23 22:52:48 +00001653 bool &IsUTF16,
1654 unsigned &StringLength) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00001655 StringRef String = Literal->getString();
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00001656 unsigned NumBytes = String.size();
Daniel Dunbar1d552912009-07-23 22:52:48 +00001657
Daniel Dunbarf015b032009-09-22 10:03:52 +00001658 // Check for simple case.
1659 if (!Literal->containsNonAsciiOrNull()) {
1660 StringLength = NumBytes;
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00001661 return Map.GetOrCreateValue(String);
Daniel Dunbarf015b032009-09-22 10:03:52 +00001662 }
1663
Daniel Dunbar1d552912009-07-23 22:52:48 +00001664 // Otherwise, convert the UTF8 literals into a byte string.
Chris Lattner5f9e2722011-07-23 10:55:15 +00001665 SmallVector<UTF16, 128> ToBuf(NumBytes);
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00001666 const UTF8 *FromPtr = (UTF8 *)String.data();
Daniel Dunbar1d552912009-07-23 22:52:48 +00001667 UTF16 *ToPtr = &ToBuf[0];
Mike Stump1eb44332009-09-09 15:08:12 +00001668
Fariborz Jahaniane7ddfb92010-09-07 19:57:04 +00001669 (void)ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
1670 &ToPtr, ToPtr + NumBytes,
1671 strictConversion);
Mike Stump1eb44332009-09-09 15:08:12 +00001672
Daniel Dunbar70ee9752009-07-23 23:41:22 +00001673 // ConvertUTF8toUTF16 returns the length in ToPtr.
Daniel Dunbar1d552912009-07-23 22:52:48 +00001674 StringLength = ToPtr - &ToBuf[0];
Daniel Dunbar70ee9752009-07-23 23:41:22 +00001675
1676 // Render the UTF-16 string into a byte array and convert to the target byte
1677 // order.
1678 //
1679 // FIXME: This isn't something we should need to do here.
1680 llvm::SmallString<128> AsBytes;
1681 AsBytes.reserve(StringLength * 2);
1682 for (unsigned i = 0; i != StringLength; ++i) {
1683 unsigned short Val = ToBuf[i];
1684 if (TargetIsLSB) {
1685 AsBytes.push_back(Val & 0xFF);
1686 AsBytes.push_back(Val >> 8);
1687 } else {
1688 AsBytes.push_back(Val >> 8);
1689 AsBytes.push_back(Val & 0xFF);
1690 }
1691 }
Daniel Dunbar434da482009-08-03 21:47:08 +00001692 // Append one extra null character, the second is automatically added by our
1693 // caller.
1694 AsBytes.push_back(0);
Daniel Dunbar70ee9752009-07-23 23:41:22 +00001695
Daniel Dunbar1d552912009-07-23 22:52:48 +00001696 IsUTF16 = true;
Chris Lattner5f9e2722011-07-23 10:55:15 +00001697 return Map.GetOrCreateValue(StringRef(AsBytes.data(), AsBytes.size()));
Daniel Dunbar1d552912009-07-23 22:52:48 +00001698}
1699
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00001700static llvm::StringMapEntry<llvm::Constant*> &
1701GetConstantStringEntry(llvm::StringMap<llvm::Constant*> &Map,
1702 const StringLiteral *Literal,
1703 unsigned &StringLength)
1704{
Chris Lattner5f9e2722011-07-23 10:55:15 +00001705 StringRef String = Literal->getString();
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00001706 StringLength = String.size();
1707 return Map.GetOrCreateValue(String);
1708}
1709
Daniel Dunbar1d552912009-07-23 22:52:48 +00001710llvm::Constant *
1711CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
1712 unsigned StringLength = 0;
1713 bool isUTF16 = false;
1714 llvm::StringMapEntry<llvm::Constant*> &Entry =
Mike Stump1eb44332009-09-09 15:08:12 +00001715 GetConstantCFStringEntry(CFConstantStringMap, Literal,
Daniel Dunbar70ee9752009-07-23 23:41:22 +00001716 getTargetData().isLittleEndian(),
1717 isUTF16, StringLength);
Mike Stump1eb44332009-09-09 15:08:12 +00001718
Daniel Dunbar1d552912009-07-23 22:52:48 +00001719 if (llvm::Constant *C = Entry.getValue())
1720 return C;
Mike Stump1eb44332009-09-09 15:08:12 +00001721
Owen Anderson0032b272009-08-13 21:57:51 +00001722 llvm::Constant *Zero =
1723 llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext));
Daniel Dunbar3e9df992008-08-23 18:37:06 +00001724 llvm::Constant *Zeros[] = { Zero, Zero };
Mike Stump1eb44332009-09-09 15:08:12 +00001725
Chris Lattner9d4a15f2009-07-16 16:48:25 +00001726 // If we don't already have it, get __CFConstantStringClassReference.
Anders Carlssonc9e20912007-08-21 00:21:21 +00001727 if (!CFConstantStringClassRef) {
Chris Lattner2acc6e32011-07-18 04:24:23 +00001728 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00001729 Ty = llvm::ArrayType::get(Ty, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001730 llvm::Constant *GV = CreateRuntimeVariable(Ty,
Chris Lattner9d4a15f2009-07-16 16:48:25 +00001731 "__CFConstantStringClassReference");
Daniel Dunbar3e9df992008-08-23 18:37:06 +00001732 // Decay array -> ptr
1733 CFConstantStringClassRef =
Jay Foada5c04342011-07-21 14:31:17 +00001734 llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Anders Carlssonc9e20912007-08-21 00:21:21 +00001735 }
Mike Stump1eb44332009-09-09 15:08:12 +00001736
Anders Carlssone3daa762008-11-15 18:54:24 +00001737 QualType CFTy = getContext().getCFConstantStringType();
Daniel Dunbar3e9df992008-08-23 18:37:06 +00001738
Chris Lattner2acc6e32011-07-18 04:24:23 +00001739 llvm::StructType *STy =
Anders Carlssone3daa762008-11-15 18:54:24 +00001740 cast<llvm::StructType>(getTypes().ConvertType(CFTy));
1741
Anders Carlsson5add6832009-08-16 05:55:31 +00001742 std::vector<llvm::Constant*> Fields(4);
Douglas Gregor44b43212008-12-11 16:49:14 +00001743
Anders Carlssonc9e20912007-08-21 00:21:21 +00001744 // Class pointer.
Anders Carlsson5add6832009-08-16 05:55:31 +00001745 Fields[0] = CFConstantStringClassRef;
Mike Stump1eb44332009-09-09 15:08:12 +00001746
Anders Carlssonc9e20912007-08-21 00:21:21 +00001747 // Flags.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001748 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
Mike Stump1eb44332009-09-09 15:08:12 +00001749 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
Anders Carlsson5add6832009-08-16 05:55:31 +00001750 llvm::ConstantInt::get(Ty, 0x07C8);
1751
Anders Carlssonc9e20912007-08-21 00:21:21 +00001752 // String pointer.
Owen Anderson0032b272009-08-13 21:57:51 +00001753 llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str());
Daniel Dunbara9668e02009-04-03 00:57:44 +00001754
Chris Lattner95b851e2009-07-16 05:03:48 +00001755 llvm::GlobalValue::LinkageTypes Linkage;
Chris Lattner278b9f02009-10-14 05:55:45 +00001756 bool isConstant;
Daniel Dunbara9668e02009-04-03 00:57:44 +00001757 if (isUTF16) {
Chris Lattner278b9f02009-10-14 05:55:45 +00001758 // FIXME: why do utf strings get "_" labels instead of "L" labels?
Chris Lattner95b851e2009-07-16 05:03:48 +00001759 Linkage = llvm::GlobalValue::InternalLinkage;
Chris Lattner278b9f02009-10-14 05:55:45 +00001760 // Note: -fwritable-strings doesn't make unicode CFStrings writable, but
1761 // does make plain ascii ones writable.
Daniel Dunbara9668e02009-04-03 00:57:44 +00001762 isConstant = true;
Chris Lattner278b9f02009-10-14 05:55:45 +00001763 } else {
Rafael Espindola584acf22011-03-14 17:55:00 +00001764 // FIXME: With OS X ld 123.2 (xcode 4) and LTO we would get a linker error
1765 // when using private linkage. It is not clear if this is a bug in ld
1766 // or a reasonable new restriction.
Rafael Espindoladc0f1372011-03-14 21:08:19 +00001767 Linkage = llvm::GlobalValue::LinkerPrivateLinkage;
Chris Lattner278b9f02009-10-14 05:55:45 +00001768 isConstant = !Features.WritableStrings;
Daniel Dunbara9668e02009-04-03 00:57:44 +00001769 }
Chris Lattner278b9f02009-10-14 05:55:45 +00001770
Mike Stump1eb44332009-09-09 15:08:12 +00001771 llvm::GlobalVariable *GV =
Chris Lattner278b9f02009-10-14 05:55:45 +00001772 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
1773 ".str");
Rafael Espindolab266a1f2011-01-17 16:31:00 +00001774 GV->setUnnamedAddr(true);
Daniel Dunbara9668e02009-04-03 00:57:44 +00001775 if (isUTF16) {
Ken Dyck4da244c2010-01-26 18:46:23 +00001776 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
1777 GV->setAlignment(Align.getQuantity());
Daniel Dunbarf7e903d2011-04-12 23:30:52 +00001778 } else {
1779 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
1780 GV->setAlignment(Align.getQuantity());
Daniel Dunbara9668e02009-04-03 00:57:44 +00001781 }
Jay Foada5c04342011-07-21 14:31:17 +00001782 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Anders Carlsson5add6832009-08-16 05:55:31 +00001783
Anders Carlssonc9e20912007-08-21 00:21:21 +00001784 // String length.
1785 Ty = getTypes().ConvertType(getContext().LongTy);
Anders Carlsson5add6832009-08-16 05:55:31 +00001786 Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
Mike Stump1eb44332009-09-09 15:08:12 +00001787
Anders Carlssonc9e20912007-08-21 00:21:21 +00001788 // The struct.
Owen Anderson08e25242009-07-27 22:29:56 +00001789 C = llvm::ConstantStruct::get(STy, Fields);
Mike Stump1eb44332009-09-09 15:08:12 +00001790 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
1791 llvm::GlobalVariable::PrivateLinkage, C,
Chris Lattner95b851e2009-07-16 05:03:48 +00001792 "_unnamed_cfstring_");
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00001793 if (const char *Sect = getContext().getTargetInfo().getCFStringSection())
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00001794 GV->setSection(Sect);
Daniel Dunbar1d552912009-07-23 22:52:48 +00001795 Entry.setValue(GV);
Mike Stump1eb44332009-09-09 15:08:12 +00001796
Anders Carlsson0c678292007-11-01 00:41:52 +00001797 return GV;
Anders Carlssonc9e20912007-08-21 00:21:21 +00001798}
Chris Lattner45e8cbd2007-11-28 05:34:05 +00001799
Douglas Gregor45c4ea72011-08-09 15:54:21 +00001800static RecordDecl *
1801CreateRecordDecl(const ASTContext &Ctx, RecordDecl::TagKind TK,
1802 DeclContext *DC, IdentifierInfo *Id) {
1803 SourceLocation Loc;
1804 if (Ctx.getLangOptions().CPlusPlus)
1805 return CXXRecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
1806 else
1807 return RecordDecl::Create(Ctx, TK, DC, Loc, Loc, Id);
1808}
1809
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00001810llvm::Constant *
Fariborz Jahanian4c733072010-10-19 17:19:29 +00001811CodeGenModule::GetAddrOfConstantString(const StringLiteral *Literal) {
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001812 unsigned StringLength = 0;
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001813 llvm::StringMapEntry<llvm::Constant*> &Entry =
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00001814 GetConstantStringEntry(CFConstantStringMap, Literal, StringLength);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001815
1816 if (llvm::Constant *C = Entry.getValue())
1817 return C;
1818
1819 llvm::Constant *Zero =
1820 llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext));
1821 llvm::Constant *Zeros[] = { Zero, Zero };
1822
Fariborz Jahanianec951e02010-04-23 22:33:39 +00001823 // If we don't already have it, get _NSConstantStringClassReference.
Fariborz Jahanian4c733072010-10-19 17:19:29 +00001824 if (!ConstantStringClassRef) {
1825 std::string StringClass(getLangOptions().ObjCConstantStringClass);
Chris Lattner2acc6e32011-07-18 04:24:23 +00001826 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Fariborz Jahanian4c733072010-10-19 17:19:29 +00001827 llvm::Constant *GV;
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00001828 if (Features.ObjCNonFragileABI) {
Fariborz Jahanian25dba5d2011-05-17 22:46:11 +00001829 std::string str =
1830 StringClass.empty() ? "OBJC_CLASS_$_NSConstantString"
1831 : "OBJC_CLASS_$_" + StringClass;
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00001832 GV = getObjCRuntime().GetClassGlobal(str);
1833 // Make sure the result is of the correct type.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001834 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00001835 ConstantStringClassRef =
1836 llvm::ConstantExpr::getBitCast(GV, PTy);
1837 } else {
Fariborz Jahanian25dba5d2011-05-17 22:46:11 +00001838 std::string str =
1839 StringClass.empty() ? "_NSConstantStringClassReference"
1840 : "_" + StringClass + "ClassReference";
Chris Lattner2acc6e32011-07-18 04:24:23 +00001841 llvm::Type *PTy = llvm::ArrayType::get(Ty, 0);
Fariborz Jahanian25dba5d2011-05-17 22:46:11 +00001842 GV = CreateRuntimeVariable(PTy, str);
Fariborz Jahanian6f40e222011-05-17 22:21:16 +00001843 // Decay array -> ptr
1844 ConstantStringClassRef =
Jay Foada5c04342011-07-21 14:31:17 +00001845 llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Fariborz Jahanian4c733072010-10-19 17:19:29 +00001846 }
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001847 }
Douglas Gregor45c4ea72011-08-09 15:54:21 +00001848
1849 if (!NSConstantStringType) {
1850 // Construct the type for a constant NSString.
1851 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
1852 Context.getTranslationUnitDecl(),
1853 &Context.Idents.get("__builtin_NSString"));
1854 D->startDefinition();
1855
1856 QualType FieldTypes[3];
1857
1858 // const int *isa;
1859 FieldTypes[0] = Context.getPointerType(Context.IntTy.withConst());
1860 // const char *str;
1861 FieldTypes[1] = Context.getPointerType(Context.CharTy.withConst());
1862 // unsigned int length;
1863 FieldTypes[2] = Context.UnsignedIntTy;
1864
1865 // Create fields
1866 for (unsigned i = 0; i < 3; ++i) {
1867 FieldDecl *Field = FieldDecl::Create(Context, D,
1868 SourceLocation(),
1869 SourceLocation(), 0,
1870 FieldTypes[i], /*TInfo=*/0,
1871 /*BitWidth=*/0,
1872 /*Mutable=*/false,
1873 /*HasInit=*/false);
1874 Field->setAccess(AS_public);
1875 D->addDecl(Field);
1876 }
1877
1878 D->completeDefinition();
1879 QualType NSTy = Context.getTagDeclType(D);
1880 NSConstantStringType = cast<llvm::StructType>(getTypes().ConvertType(NSTy));
1881 }
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001882
1883 std::vector<llvm::Constant*> Fields(3);
1884
1885 // Class pointer.
Fariborz Jahanian4c733072010-10-19 17:19:29 +00001886 Fields[0] = ConstantStringClassRef;
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001887
1888 // String pointer.
1889 llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str());
1890
1891 llvm::GlobalValue::LinkageTypes Linkage;
1892 bool isConstant;
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00001893 Linkage = llvm::GlobalValue::PrivateLinkage;
1894 isConstant = !Features.WritableStrings;
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001895
1896 llvm::GlobalVariable *GV =
1897 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
1898 ".str");
Rafael Espindola803d3072011-01-17 22:11:21 +00001899 GV->setUnnamedAddr(true);
Fariborz Jahaniancf8e1682011-05-13 18:13:10 +00001900 CharUnits Align = getContext().getTypeAlignInChars(getContext().CharTy);
1901 GV->setAlignment(Align.getQuantity());
Jay Foada5c04342011-07-21 14:31:17 +00001902 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001903
1904 // String length.
Chris Lattner2acc6e32011-07-18 04:24:23 +00001905 llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001906 Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
1907
1908 // The struct.
Douglas Gregor45c4ea72011-08-09 15:54:21 +00001909 C = llvm::ConstantStruct::get(NSConstantStringType, Fields);
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001910 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
1911 llvm::GlobalVariable::PrivateLinkage, C,
1912 "_unnamed_nsstring_");
1913 // FIXME. Fix section.
Fariborz Jahanianec951e02010-04-23 22:33:39 +00001914 if (const char *Sect =
1915 Features.ObjCNonFragileABI
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00001916 ? getContext().getTargetInfo().getNSStringNonFragileABISection()
1917 : getContext().getTargetInfo().getNSStringSection())
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001918 GV->setSection(Sect);
1919 Entry.setValue(GV);
1920
1921 return GV;
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00001922}
1923
Douglas Gregor0815b572011-08-09 17:23:49 +00001924QualType CodeGenModule::getObjCFastEnumerationStateType() {
1925 if (ObjCFastEnumerationStateType.isNull()) {
1926 RecordDecl *D = CreateRecordDecl(Context, TTK_Struct,
1927 Context.getTranslationUnitDecl(),
1928 &Context.Idents.get("__objcFastEnumerationState"));
1929 D->startDefinition();
1930
1931 QualType FieldTypes[] = {
1932 Context.UnsignedLongTy,
1933 Context.getPointerType(Context.getObjCIdType()),
1934 Context.getPointerType(Context.UnsignedLongTy),
1935 Context.getConstantArrayType(Context.UnsignedLongTy,
1936 llvm::APInt(32, 5), ArrayType::Normal, 0)
1937 };
1938
1939 for (size_t i = 0; i < 4; ++i) {
1940 FieldDecl *Field = FieldDecl::Create(Context,
1941 D,
1942 SourceLocation(),
1943 SourceLocation(), 0,
1944 FieldTypes[i], /*TInfo=*/0,
1945 /*BitWidth=*/0,
1946 /*Mutable=*/false,
1947 /*HasInit=*/false);
1948 Field->setAccess(AS_public);
1949 D->addDecl(Field);
1950 }
1951
1952 D->completeDefinition();
1953 ObjCFastEnumerationStateType = Context.getTagDeclType(D);
1954 }
1955
1956 return ObjCFastEnumerationStateType;
1957}
1958
Daniel Dunbar61432932008-08-13 23:20:05 +00001959/// GetStringForStringLiteral - Return the appropriate bytes for a
Daniel Dunbar1e049762008-08-10 20:25:57 +00001960/// string literal, properly padded to match the literal type.
Daniel Dunbar61432932008-08-13 23:20:05 +00001961std::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) {
Ken Dyck3b8037a2011-01-29 17:53:12 +00001962 const ASTContext &Context = getContext();
Daniel Dunbar1e049762008-08-10 20:25:57 +00001963 const ConstantArrayType *CAT =
Ken Dyck3b8037a2011-01-29 17:53:12 +00001964 Context.getAsConstantArrayType(E->getType());
Daniel Dunbar1e049762008-08-10 20:25:57 +00001965 assert(CAT && "String isn't pointer or array!");
Mike Stump1eb44332009-09-09 15:08:12 +00001966
Chris Lattnerdbb1ecc2009-02-26 23:01:51 +00001967 // Resize the string to the right size.
Daniel Dunbar1e049762008-08-10 20:25:57 +00001968 uint64_t RealLen = CAT->getSize().getZExtValue();
Mike Stump1eb44332009-09-09 15:08:12 +00001969
Douglas Gregor5cee1192011-07-27 05:40:30 +00001970 switch (E->getKind()) {
1971 case StringLiteral::Ascii:
1972 case StringLiteral::UTF8:
1973 break;
1974 case StringLiteral::Wide:
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00001975 RealLen *= Context.getTargetInfo().getWCharWidth() / Context.getCharWidth();
Douglas Gregor5cee1192011-07-27 05:40:30 +00001976 break;
1977 case StringLiteral::UTF16:
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00001978 RealLen *= Context.getTargetInfo().getChar16Width() / Context.getCharWidth();
Douglas Gregor5cee1192011-07-27 05:40:30 +00001979 break;
1980 case StringLiteral::UTF32:
Douglas Gregorbcfd1f52011-09-02 00:18:52 +00001981 RealLen *= Context.getTargetInfo().getChar32Width() / Context.getCharWidth();
Douglas Gregor5cee1192011-07-27 05:40:30 +00001982 break;
1983 }
Mike Stump1eb44332009-09-09 15:08:12 +00001984
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00001985 std::string Str = E->getString().str();
Daniel Dunbar1e049762008-08-10 20:25:57 +00001986 Str.resize(RealLen, '\0');
Mike Stump1eb44332009-09-09 15:08:12 +00001987
Daniel Dunbar1e049762008-08-10 20:25:57 +00001988 return Str;
1989}
1990
Daniel Dunbar61432932008-08-13 23:20:05 +00001991/// GetAddrOfConstantStringFromLiteral - Return a pointer to a
1992/// constant array for the given string literal.
1993llvm::Constant *
1994CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
1995 // FIXME: This can be more efficient.
Eli Friedman7eb79c12009-11-16 05:55:46 +00001996 // FIXME: We shouldn't need to bitcast the constant in the wide string case.
John McCalla5e19c62011-08-04 01:03:22 +00001997 CharUnits Align = getContext().getTypeAlignInChars(S->getType());
1998 llvm::Constant *C = GetAddrOfConstantString(GetStringForStringLiteral(S),
1999 /* GlobalName */ 0,
2000 Align.getQuantity());
Douglas Gregor5cee1192011-07-27 05:40:30 +00002001 if (S->isWide() || S->isUTF16() || S->isUTF32()) {
Eli Friedman7eb79c12009-11-16 05:55:46 +00002002 llvm::Type *DestTy =
2003 llvm::PointerType::getUnqual(getTypes().ConvertType(S->getType()));
2004 C = llvm::ConstantExpr::getBitCast(C, DestTy);
2005 }
2006 return C;
Daniel Dunbar61432932008-08-13 23:20:05 +00002007}
2008
Chris Lattnereaf2bb82009-02-24 22:18:39 +00002009/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
2010/// array for the given ObjCEncodeExpr node.
2011llvm::Constant *
2012CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
2013 std::string Str;
2014 getContext().getObjCEncodingForType(E->getEncodedType(), Str);
Eli Friedmana210f352009-03-07 20:17:55 +00002015
2016 return GetAddrOfConstantCString(Str);
Chris Lattnereaf2bb82009-02-24 22:18:39 +00002017}
2018
2019
Chris Lattnera7ad98f2008-02-11 00:02:17 +00002020/// GenerateWritableString -- Creates storage for a string literal.
John McCalla5e19c62011-08-04 01:03:22 +00002021static llvm::GlobalVariable *GenerateStringLiteral(StringRef str,
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002022 bool constant,
Daniel Dunbar5fabf9d2008-10-17 21:56:50 +00002023 CodeGenModule &CGM,
John McCalla5e19c62011-08-04 01:03:22 +00002024 const char *GlobalName,
2025 unsigned Alignment) {
Daniel Dunbar61432932008-08-13 23:20:05 +00002026 // Create Constant for this string literal. Don't add a '\0'.
Owen Anderson0032b272009-08-13 21:57:51 +00002027 llvm::Constant *C =
2028 llvm::ConstantArray::get(CGM.getLLVMContext(), str, false);
Mike Stump1eb44332009-09-09 15:08:12 +00002029
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002030 // Create a global variable for this string
Rafael Espindola1257bc62011-01-10 22:34:03 +00002031 llvm::GlobalVariable *GV =
2032 new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
2033 llvm::GlobalValue::PrivateLinkage,
2034 C, GlobalName);
John McCalla5e19c62011-08-04 01:03:22 +00002035 GV->setAlignment(Alignment);
Rafael Espindola1257bc62011-01-10 22:34:03 +00002036 GV->setUnnamedAddr(true);
2037 return GV;
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002038}
2039
Daniel Dunbar61432932008-08-13 23:20:05 +00002040/// GetAddrOfConstantString - Returns a pointer to a character array
2041/// containing the literal. This contents are exactly that of the
2042/// given string, i.e. it will not be null terminated automatically;
2043/// see GetAddrOfConstantCString. Note that whether the result is
2044/// actually a pointer to an LLVM constant depends on
2045/// Feature.WriteableStrings.
2046///
2047/// The result has pointer to array type.
Chris Lattner5f9e2722011-07-23 10:55:15 +00002048llvm::Constant *CodeGenModule::GetAddrOfConstantString(StringRef Str,
John McCalla5e19c62011-08-04 01:03:22 +00002049 const char *GlobalName,
2050 unsigned Alignment) {
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00002051 bool IsConstant = !Features.WritableStrings;
2052
2053 // Get the default prefix if a name wasn't specified.
2054 if (!GlobalName)
Chris Lattner95b851e2009-07-16 05:03:48 +00002055 GlobalName = ".str";
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00002056
2057 // Don't share any string literals if strings aren't constant.
2058 if (!IsConstant)
John McCalla5e19c62011-08-04 01:03:22 +00002059 return GenerateStringLiteral(Str, false, *this, GlobalName, Alignment);
Mike Stump1eb44332009-09-09 15:08:12 +00002060
John McCalla5e19c62011-08-04 01:03:22 +00002061 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
Benjamin Kramer9de43422011-03-05 13:45:23 +00002062 ConstantStringMap.GetOrCreateValue(Str);
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002063
John McCalla5e19c62011-08-04 01:03:22 +00002064 if (llvm::GlobalVariable *GV = Entry.getValue()) {
2065 if (Alignment > GV->getAlignment()) {
2066 GV->setAlignment(Alignment);
2067 }
2068 return GV;
2069 }
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002070
2071 // Create a global variable for this.
John McCalla5e19c62011-08-04 01:03:22 +00002072 llvm::GlobalVariable *GV = GenerateStringLiteral(Str, true, *this, GlobalName, Alignment);
2073 Entry.setValue(GV);
2074 return GV;
Chris Lattner45e8cbd2007-11-28 05:34:05 +00002075}
Daniel Dunbar61432932008-08-13 23:20:05 +00002076
2077/// GetAddrOfConstantCString - Returns a pointer to a character
Benjamin Kramer9de43422011-03-05 13:45:23 +00002078/// array containing the literal and a terminating '\0'
Daniel Dunbar61432932008-08-13 23:20:05 +00002079/// character. The result has pointer to array type.
Benjamin Kramer9de43422011-03-05 13:45:23 +00002080llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &Str,
John McCalla5e19c62011-08-04 01:03:22 +00002081 const char *GlobalName,
2082 unsigned Alignment) {
Chris Lattner5f9e2722011-07-23 10:55:15 +00002083 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
John McCalla5e19c62011-08-04 01:03:22 +00002084 return GetAddrOfConstantString(StrWithNull, GlobalName, Alignment);
Daniel Dunbar61432932008-08-13 23:20:05 +00002085}
Daniel Dunbar41071de2008-08-15 23:26:23 +00002086
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002087/// EmitObjCPropertyImplementations - Emit information for synthesized
2088/// properties for an implementation.
Mike Stump1eb44332009-09-09 15:08:12 +00002089void CodeGenModule::EmitObjCPropertyImplementations(const
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002090 ObjCImplementationDecl *D) {
Mike Stump1eb44332009-09-09 15:08:12 +00002091 for (ObjCImplementationDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002092 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002093 ObjCPropertyImplDecl *PID = *i;
Mike Stump1eb44332009-09-09 15:08:12 +00002094
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002095 // Dynamic is just for type-checking.
2096 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
2097 ObjCPropertyDecl *PD = PID->getPropertyDecl();
2098
2099 // Determine which methods need to be implemented, some may have
2100 // been overridden. Note that ::isSynthesized is not the method
2101 // we want, that just indicates if the decl came from a
2102 // property. What we want to know is if the method is defined in
2103 // this implementation.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002104 if (!D->getInstanceMethod(PD->getGetterName()))
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00002105 CodeGenFunction(*this).GenerateObjCGetter(
2106 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002107 if (!PD->isReadOnly() &&
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002108 !D->getInstanceMethod(PD->getSetterName()))
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00002109 CodeGenFunction(*this).GenerateObjCSetter(
2110 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002111 }
2112 }
2113}
2114
John McCalle81ac692011-03-22 07:05:39 +00002115static bool needsDestructMethod(ObjCImplementationDecl *impl) {
Jordy Rosedb8264e2011-07-22 02:08:32 +00002116 const ObjCInterfaceDecl *iface = impl->getClassInterface();
2117 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
John McCalle81ac692011-03-22 07:05:39 +00002118 ivar; ivar = ivar->getNextIvar())
2119 if (ivar->getType().isDestructedType())
2120 return true;
2121
2122 return false;
2123}
2124
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002125/// EmitObjCIvarInitializations - Emit information for ivar initialization
2126/// for an implementation.
2127void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
John McCalle81ac692011-03-22 07:05:39 +00002128 // We might need a .cxx_destruct even if we don't have any ivar initializers.
2129 if (needsDestructMethod(D)) {
2130 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
2131 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
2132 ObjCMethodDecl *DTORMethod =
2133 ObjCMethodDecl::Create(getContext(), D->getLocation(), D->getLocation(),
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002134 cxxSelector, getContext().VoidTy, 0, D,
2135 /*isInstance=*/true, /*isVariadic=*/false,
2136 /*isSynthesized=*/true, /*isImplicitlyDeclared=*/true,
2137 /*isDefined=*/false, ObjCMethodDecl::Required);
John McCalle81ac692011-03-22 07:05:39 +00002138 D->addInstanceMethod(DTORMethod);
2139 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
John McCallf85e1932011-06-15 23:02:42 +00002140 D->setHasCXXStructors(true);
John McCalle81ac692011-03-22 07:05:39 +00002141 }
2142
2143 // If the implementation doesn't have any ivar initializers, we don't need
2144 // a .cxx_construct.
David Chisnall827bbcc2011-03-17 14:19:08 +00002145 if (D->getNumIvarInitializers() == 0)
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002146 return;
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002147
John McCalle81ac692011-03-22 07:05:39 +00002148 IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
2149 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002150 // The constructor returns 'self'.
2151 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
2152 D->getLocation(),
2153 D->getLocation(), cxxSelector,
2154 getContext().getObjCIdType(), 0,
Argyrios Kyrtzidis75cf3e82011-08-17 19:25:08 +00002155 D, /*isInstance=*/true,
2156 /*isVariadic=*/false,
2157 /*isSynthesized=*/true,
2158 /*isImplicitlyDeclared=*/true,
2159 /*isDefined=*/false,
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002160 ObjCMethodDecl::Required);
2161 D->addInstanceMethod(CTORMethod);
2162 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
John McCallf85e1932011-06-15 23:02:42 +00002163 D->setHasCXXStructors(true);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002164}
2165
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002166/// EmitNamespace - Emit all declarations in a namespace.
Anders Carlsson984e0682009-04-01 00:58:25 +00002167void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002168 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
Anders Carlsson984e0682009-04-01 00:58:25 +00002169 I != E; ++I)
2170 EmitTopLevelDecl(*I);
2171}
2172
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002173// EmitLinkageSpec - Emit all declarations in a linkage spec.
2174void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
Eli Friedmanf976be82009-08-01 20:48:04 +00002175 if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
2176 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002177 ErrorUnsupported(LSD, "linkage spec");
2178 return;
2179 }
2180
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00002181 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002182 I != E; ++I)
2183 EmitTopLevelDecl(*I);
2184}
2185
Daniel Dunbar41071de2008-08-15 23:26:23 +00002186/// EmitTopLevelDecl - Emit code for a single top level declaration.
2187void CodeGenModule::EmitTopLevelDecl(Decl *D) {
2188 // If an error has occurred, stop code generation, but continue
2189 // parsing and semantic analysis (to ensure all warnings and errors
2190 // are emitted).
2191 if (Diags.hasErrorOccurred())
2192 return;
2193
Douglas Gregor16e8be22009-06-29 17:30:29 +00002194 // Ignore dependent declarations.
2195 if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
2196 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002197
Daniel Dunbar41071de2008-08-15 23:26:23 +00002198 switch (D->getKind()) {
Anders Carlsson293361a2009-08-25 13:14:46 +00002199 case Decl::CXXConversion:
Anders Carlsson2b77ba82009-04-04 20:47:02 +00002200 case Decl::CXXMethod:
Daniel Dunbar41071de2008-08-15 23:26:23 +00002201 case Decl::Function:
Douglas Gregor16e8be22009-06-29 17:30:29 +00002202 // Skip function templates
Francois Pichet8387e2a2011-04-22 22:18:13 +00002203 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2204 cast<FunctionDecl>(D)->isLateTemplateParsed())
Douglas Gregor16e8be22009-06-29 17:30:29 +00002205 return;
Mike Stump1eb44332009-09-09 15:08:12 +00002206
Anders Carlsson555b4bb2009-09-10 23:43:36 +00002207 EmitGlobal(cast<FunctionDecl>(D));
2208 break;
2209
Daniel Dunbar41071de2008-08-15 23:26:23 +00002210 case Decl::Var:
Anders Carlsson555b4bb2009-09-10 23:43:36 +00002211 EmitGlobal(cast<VarDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002212 break;
2213
John McCall26fbc722011-04-12 01:01:22 +00002214 // Indirect fields from global anonymous structs and unions can be
2215 // ignored; only the actual variable requires IR gen support.
2216 case Decl::IndirectField:
2217 break;
2218
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002219 // C++ Decls
Daniel Dunbar41071de2008-08-15 23:26:23 +00002220 case Decl::Namespace:
Anders Carlsson984e0682009-04-01 00:58:25 +00002221 EmitNamespace(cast<NamespaceDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002222 break;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002223 // No code generation needed.
John McCall9d0c6612009-11-17 09:33:40 +00002224 case Decl::UsingShadow:
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002225 case Decl::Using:
Douglas Gregordd9967a2009-09-02 23:49:23 +00002226 case Decl::UsingDirective:
Douglas Gregor127102b2009-06-29 20:59:39 +00002227 case Decl::ClassTemplate:
2228 case Decl::FunctionTemplate:
Richard Smith3e4c6c42011-05-05 21:57:07 +00002229 case Decl::TypeAliasTemplate:
Anders Carlsson018837b2009-09-23 19:19:16 +00002230 case Decl::NamespaceAlias:
Douglas Gregor6a576ab2011-06-05 05:04:23 +00002231 case Decl::Block:
Douglas Gregor9cfbe482009-06-20 00:51:54 +00002232 break;
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002233 case Decl::CXXConstructor:
Anders Carlsson1fe598c2009-11-24 05:16:24 +00002234 // Skip function templates
Francois Pichet8387e2a2011-04-22 22:18:13 +00002235 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate() ||
2236 cast<FunctionDecl>(D)->isLateTemplateParsed())
Anders Carlsson1fe598c2009-11-24 05:16:24 +00002237 return;
2238
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002239 EmitCXXConstructors(cast<CXXConstructorDecl>(D));
2240 break;
Anders Carlsson27ae5362009-04-17 01:58:57 +00002241 case Decl::CXXDestructor:
Francois Pichet8387e2a2011-04-22 22:18:13 +00002242 if (cast<FunctionDecl>(D)->isLateTemplateParsed())
2243 return;
Anders Carlsson27ae5362009-04-17 01:58:57 +00002244 EmitCXXDestructors(cast<CXXDestructorDecl>(D));
2245 break;
Anders Carlsson36674d22009-06-11 21:22:55 +00002246
2247 case Decl::StaticAssert:
2248 // Nothing to do.
2249 break;
2250
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00002251 // Objective-C Decls
Mike Stump1eb44332009-09-09 15:08:12 +00002252
Fariborz Jahanian38e24c72009-03-18 22:33:24 +00002253 // Forward declarations, no (immediate) code generation.
Daniel Dunbar41071de2008-08-15 23:26:23 +00002254 case Decl::ObjCClass:
Daniel Dunbar41071de2008-08-15 23:26:23 +00002255 case Decl::ObjCForwardProtocol:
Chris Lattner285d0db2009-04-01 02:36:43 +00002256 case Decl::ObjCInterface:
Chris Lattner285d0db2009-04-01 02:36:43 +00002257 break;
Fariborz Jahanian000835d2010-08-23 18:51:39 +00002258
Chris Lattnerbaf101d2011-04-09 07:11:53 +00002259 case Decl::ObjCCategory: {
2260 ObjCCategoryDecl *CD = cast<ObjCCategoryDecl>(D);
2261 if (CD->IsClassExtension() && CD->hasSynthBitfield())
2262 Context.ResetObjCLayout(CD->getClassInterface());
2263 break;
2264 }
Chris Lattner285d0db2009-04-01 02:36:43 +00002265
Daniel Dunbar41071de2008-08-15 23:26:23 +00002266 case Decl::ObjCProtocol:
Peter Collingbournee9265232011-07-27 20:29:46 +00002267 ObjCRuntime->GenerateProtocol(cast<ObjCProtocolDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002268 break;
2269
2270 case Decl::ObjCCategoryImpl:
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002271 // Categories have properties but don't support synthesize so we
2272 // can ignore them here.
Peter Collingbournee9265232011-07-27 20:29:46 +00002273 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002274 break;
2275
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002276 case Decl::ObjCImplementation: {
2277 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
Fariborz Jahanian000835d2010-08-23 18:51:39 +00002278 if (Features.ObjCNonFragileABI2 && OMD->hasSynthBitfield())
2279 Context.ResetObjCLayout(OMD->getClassInterface());
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00002280 EmitObjCPropertyImplementations(OMD);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00002281 EmitObjCIvarInitializations(OMD);
Peter Collingbournee9265232011-07-27 20:29:46 +00002282 ObjCRuntime->GenerateClass(OMD);
Daniel Dunbar41071de2008-08-15 23:26:23 +00002283 break;
Mike Stump1eb44332009-09-09 15:08:12 +00002284 }
Daniel Dunbar41071de2008-08-15 23:26:23 +00002285 case Decl::ObjCMethod: {
2286 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
2287 // If this is not a prototype, emit the body.
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +00002288 if (OMD->getBody())
Daniel Dunbar41071de2008-08-15 23:26:23 +00002289 CodeGenFunction(*this).GenerateObjCMethod(OMD);
2290 break;
2291 }
Mike Stump1eb44332009-09-09 15:08:12 +00002292 case Decl::ObjCCompatibleAlias:
Fariborz Jahanian305c6582009-01-08 01:10:55 +00002293 // compatibility-alias is a directive and has no code gen.
Daniel Dunbar41071de2008-08-15 23:26:23 +00002294 break;
2295
Anders Carlsson91e20dd2009-04-02 05:55:18 +00002296 case Decl::LinkageSpec:
2297 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00002298 break;
Daniel Dunbar41071de2008-08-15 23:26:23 +00002299
2300 case Decl::FileScopeAsm: {
2301 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
Chris Lattner5f9e2722011-07-23 10:55:15 +00002302 StringRef AsmString = AD->getAsmString()->getString();
Mike Stump1eb44332009-09-09 15:08:12 +00002303
Daniel Dunbar41071de2008-08-15 23:26:23 +00002304 const std::string &S = getModule().getModuleInlineAsm();
2305 if (S.empty())
2306 getModule().setModuleInlineAsm(AsmString);
Chris Lattner9f5bff02011-07-23 20:04:25 +00002307 else if (*--S.end() == '\n')
2308 getModule().setModuleInlineAsm(S + AsmString.str());
Daniel Dunbar41071de2008-08-15 23:26:23 +00002309 else
Benjamin Kramer8d042582009-12-11 13:33:18 +00002310 getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
Daniel Dunbar41071de2008-08-15 23:26:23 +00002311 break;
2312 }
Mike Stump1eb44332009-09-09 15:08:12 +00002313
2314 default:
Mike Stumpf5408fe2009-05-16 07:57:57 +00002315 // Make sure we handled everything we should, every other kind is a
2316 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
2317 // function. Need to recode Decl::Kind to do that easily.
Daniel Dunbar41071de2008-08-15 23:26:23 +00002318 assert(isa<TypeDecl>(D) && "Unsupported decl kind");
2319 }
2320}
John McCall744016d2010-07-06 23:57:41 +00002321
2322/// Turns the given pointer into a constant.
2323static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
2324 const void *Ptr) {
2325 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
Chris Lattner2acc6e32011-07-18 04:24:23 +00002326 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
John McCall744016d2010-07-06 23:57:41 +00002327 return llvm::ConstantInt::get(i64, PtrInt);
2328}
2329
2330static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
2331 llvm::NamedMDNode *&GlobalMetadata,
2332 GlobalDecl D,
2333 llvm::GlobalValue *Addr) {
2334 if (!GlobalMetadata)
2335 GlobalMetadata =
2336 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
2337
2338 // TODO: should we report variant information for ctors/dtors?
2339 llvm::Value *Ops[] = {
2340 Addr,
2341 GetPointerConstant(CGM.getLLVMContext(), D.getDecl())
2342 };
Jay Foad6f141652011-04-21 19:59:12 +00002343 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
John McCall744016d2010-07-06 23:57:41 +00002344}
2345
2346/// Emits metadata nodes associating all the global values in the
2347/// current module with the Decls they came from. This is useful for
2348/// projects using IR gen as a subroutine.
2349///
2350/// Since there's currently no way to associate an MDNode directly
2351/// with an llvm::GlobalValue, we create a global named metadata
2352/// with the name 'clang.global.decl.ptrs'.
2353void CodeGenModule::EmitDeclMetadata() {
2354 llvm::NamedMDNode *GlobalMetadata = 0;
2355
2356 // StaticLocalDeclMap
Chris Lattner5f9e2722011-07-23 10:55:15 +00002357 for (llvm::DenseMap<GlobalDecl,StringRef>::iterator
John McCall744016d2010-07-06 23:57:41 +00002358 I = MangledDeclNames.begin(), E = MangledDeclNames.end();
2359 I != E; ++I) {
2360 llvm::GlobalValue *Addr = getModule().getNamedValue(I->second);
2361 EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr);
2362 }
2363}
2364
2365/// Emits metadata nodes for all the local variables in the current
2366/// function.
2367void CodeGenFunction::EmitDeclMetadata() {
2368 if (LocalDeclMap.empty()) return;
2369
2370 llvm::LLVMContext &Context = getLLVMContext();
2371
2372 // Find the unique metadata ID for this name.
2373 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
2374
2375 llvm::NamedMDNode *GlobalMetadata = 0;
2376
2377 for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator
2378 I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) {
2379 const Decl *D = I->first;
2380 llvm::Value *Addr = I->second;
2381
2382 if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
2383 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
Jay Foad6f141652011-04-21 19:59:12 +00002384 Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, DAddr));
John McCall744016d2010-07-06 23:57:41 +00002385 } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
2386 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
2387 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
2388 }
2389 }
2390}
Daniel Dunbar673431a2010-07-16 00:00:15 +00002391
Nick Lewycky3dc05412011-05-05 00:08:20 +00002392void CodeGenModule::EmitCoverageFile() {
2393 if (!getCodeGenOpts().CoverageFile.empty()) {
Nick Lewycky5ea4f442011-05-04 20:46:58 +00002394 if (llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu")) {
2395 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
2396 llvm::LLVMContext &Ctx = TheModule.getContext();
Nick Lewycky3dc05412011-05-05 00:08:20 +00002397 llvm::MDString *CoverageFile =
2398 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageFile);
Nick Lewycky5ea4f442011-05-04 20:46:58 +00002399 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
2400 llvm::MDNode *CU = CUNode->getOperand(i);
Nick Lewycky3dc05412011-05-05 00:08:20 +00002401 llvm::Value *node[] = { CoverageFile, CU };
Nick Lewycky5ea4f442011-05-04 20:46:58 +00002402 llvm::MDNode *N = llvm::MDNode::get(Ctx, node);
2403 GCov->addOperand(N);
2404 }
2405 }
2406 }
2407}