blob: 2d9d57393ef79d431bb5001b32a0e8c7ed60f4c1 [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"
Daniel Dunbar0dbe2272008-09-08 21:33:45 +000017#include "CGCall.h"
Daniel Dunbaraf2f62c2008-08-13 00:59:25 +000018#include "CGObjCRuntime.h"
Douglas Gregor5f2bfd42009-02-13 00:10:09 +000019#include "Mangle.h"
Anton Korobeynikov82d0a412010-01-10 12:58:08 +000020#include "TargetInfo.h"
Chandler Carruth06057ce2010-06-15 23:19:56 +000021#include "clang/Frontend/CodeGenOptions.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000022#include "clang/AST/ASTContext.h"
Ken Dyck687cc4a2010-01-26 13:48:07 +000023#include "clang/AST/CharUnits.h"
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +000024#include "clang/AST/DeclObjC.h"
Chris Lattner21ef7ae2008-11-04 16:51:42 +000025#include "clang/AST/DeclCXX.h"
Douglas Gregoraf896892010-06-21 18:41:26 +000026#include "clang/AST/DeclTemplate.h"
Anders Carlsson1a5e0d72009-11-30 23:41:22 +000027#include "clang/AST/RecordLayout.h"
Chris Lattner1b63e4f2009-06-14 01:54:56 +000028#include "clang/Basic/Builtins.h"
Chris Lattner2c8569d2007-12-02 07:19:18 +000029#include "clang/Basic/Diagnostic.h"
Nate Begeman8bd4afe2008-04-19 04:17:09 +000030#include "clang/Basic/SourceManager.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000031#include "clang/Basic/TargetInfo.h"
Steve Naroffe9b7d8a2009-04-01 15:50:34 +000032#include "clang/Basic/ConvertUTF.h"
Nate Begemanec9426c2008-03-09 03:09:36 +000033#include "llvm/CallingConv.h"
Chris Lattnerbef20ac2007-08-31 04:31:45 +000034#include "llvm/Module.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000035#include "llvm/Intrinsics.h"
Chris Lattnerd5b89022009-12-28 21:44:41 +000036#include "llvm/LLVMContext.h"
John McCall6374c332010-03-06 00:35:14 +000037#include "llvm/ADT/Triple.h"
Anton Korobeynikov20ff3102008-06-01 14:13:53 +000038#include "llvm/Target/TargetData.h"
Gabor Greif6ba728d2010-04-10 02:56:12 +000039#include "llvm/Support/CallSite.h"
Chris Lattner78f7ece2009-11-07 09:22:46 +000040#include "llvm/Support/ErrorHandling.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000041using namespace clang;
42using namespace CodeGen;
43
44
Chandler Carruth2811ccf2009-11-12 17:24:48 +000045CodeGenModule::CodeGenModule(ASTContext &C, const CodeGenOptions &CGO,
John McCall468ec6c2010-03-04 04:29:44 +000046 llvm::Module &M, const llvm::TargetData &TD,
47 Diagnostic &diags)
Chris Lattnerbd360642009-03-26 05:00:52 +000048 : BlockModule(C, M, TD, Types, *this), Context(C),
Chandler Carruth2811ccf2009-11-12 17:24:48 +000049 Features(C.getLangOptions()), CodeGenOpts(CGO), TheModule(M),
John McCall468ec6c2010-03-04 04:29:44 +000050 TheTargetData(TD), TheTargetCodeGenInfo(0), Diags(diags),
Anton Korobeynikov82d0a412010-01-10 12:58:08 +000051 Types(C, M, TD, getTargetCodeGenInfo().getABIInfo()),
Charles Davis3a811f12010-05-25 19:52:27 +000052 VTables(*this), Runtime(0), ABI(0),
Daniel Dunbar673431a2010-07-16 00:00:15 +000053 CFConstantStringClassRef(0), NSConstantStringClassRef(0),
54 VMContext(M.getContext()),
Daniel Dunbar754b9fb2010-07-16 00:00:19 +000055 NSConcreteGlobalBlockDecl(0), NSConcreteStackBlockDecl(0),
Daniel Dunbar673431a2010-07-16 00:00:15 +000056 NSConcreteGlobalBlock(0), NSConcreteStackBlock(0),
Daniel Dunbar754b9fb2010-07-16 00:00:19 +000057 BlockObjectAssignDecl(0), BlockObjectDisposeDecl(0),
Daniel Dunbar673431a2010-07-16 00:00:15 +000058 BlockObjectAssign(0), BlockObjectDispose(0){
Daniel Dunbar208ff5e2008-08-11 18:12:00 +000059
Chris Lattner3c8f1532009-03-21 07:12:05 +000060 if (!Features.ObjC1)
61 Runtime = 0;
62 else if (!Features.NeXTRuntime)
63 Runtime = CreateGNUObjCRuntime(*this);
64 else if (Features.ObjCNonFragileABI)
65 Runtime = CreateMacNonFragileABIObjCRuntime(*this);
66 else
67 Runtime = CreateMacObjCRuntime(*this);
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +000068
Charles Davis3a811f12010-05-25 19:52:27 +000069 if (!Features.CPlusPlus)
70 ABI = 0;
71 else createCXXABI();
72
Sanjiv Guptae8b9f5b2008-05-08 08:54:20 +000073 // If debug info generation is enabled, create the CGDebugInfo object.
Anders Carlsson20f12a22009-12-06 18:00:51 +000074 DebugInfo = CodeGenOpts.DebugInfo ? new CGDebugInfo(*this) : 0;
Chris Lattner2b94fe32008-03-01 08:45:05 +000075}
76
77CodeGenModule::~CodeGenModule() {
Ted Kremenek815c78f2008-08-05 18:50:11 +000078 delete Runtime;
Charles Davis3a811f12010-05-25 19:52:27 +000079 delete ABI;
Ted Kremenek815c78f2008-08-05 18:50:11 +000080 delete DebugInfo;
81}
82
David Chisnall0d13f6f2010-01-23 02:40:42 +000083void CodeGenModule::createObjCRuntime() {
84 if (!Features.NeXTRuntime)
85 Runtime = CreateGNUObjCRuntime(*this);
86 else if (Features.ObjCNonFragileABI)
87 Runtime = CreateMacNonFragileABIObjCRuntime(*this);
88 else
89 Runtime = CreateMacObjCRuntime(*this);
90}
91
Charles Davis3a811f12010-05-25 19:52:27 +000092void CodeGenModule::createCXXABI() {
Charles Davis20cf7172010-08-19 02:18:14 +000093 switch (Context.Target.getCXXABI()) {
John McCallee79a4c2010-08-21 22:46:04 +000094 case CXXABI_ARM:
95 ABI = CreateARMCXXABI(*this);
96 break;
97 case CXXABI_Itanium:
Charles Davis98b7c5c2010-06-11 01:06:47 +000098 ABI = CreateItaniumCXXABI(*this);
Charles Davis20cf7172010-08-19 02:18:14 +000099 break;
100 case CXXABI_Microsoft:
101 ABI = CreateMicrosoftCXXABI(*this);
John McCallee79a4c2010-08-21 22:46:04 +0000102 break;
Charles Davis20cf7172010-08-19 02:18:14 +0000103 }
Charles Davis3a811f12010-05-25 19:52:27 +0000104}
105
Ted Kremenek815c78f2008-08-05 18:50:11 +0000106void CodeGenModule::Release() {
Chris Lattner82227ff2009-03-22 21:21:57 +0000107 EmitDeferred();
Eli Friedman6c6bda32010-01-08 00:50:11 +0000108 EmitCXXGlobalInitFunc();
Daniel Dunbarefb0fa92010-03-20 04:15:41 +0000109 EmitCXXGlobalDtorFunc();
Daniel Dunbar208ff5e2008-08-11 18:12:00 +0000110 if (Runtime)
111 if (llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction())
112 AddGlobalCtor(ObjCInitFunction);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000113 EmitCtorList(GlobalCtors, "llvm.global_ctors");
114 EmitCtorList(GlobalDtors, "llvm.global_dtors");
Nate Begeman532485c2008-04-18 23:43:57 +0000115 EmitAnnotations();
Daniel Dunbar02698712009-02-13 20:29:50 +0000116 EmitLLVMUsed();
John McCall744016d2010-07-06 23:57:41 +0000117
118 if (getCodeGenOpts().EmitDeclMetadata)
119 EmitDeclMetadata();
Daniel Dunbarf1968f22008-10-01 00:49:24 +0000120}
121
John McCall6374c332010-03-06 00:35:14 +0000122bool CodeGenModule::isTargetDarwin() const {
123 return getContext().Target.getTriple().getOS() == llvm::Triple::Darwin;
124}
125
Daniel Dunbar488e9932008-08-16 00:56:44 +0000126/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattner2c8569d2007-12-02 07:19:18 +0000127/// specified stmt yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000128void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type,
129 bool OmitOnError) {
130 if (OmitOnError && getDiags().hasErrorOccurred())
131 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000132 unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
Daniel Dunbar56b80012009-02-06 19:18:03 +0000133 "cannot compile this %0 yet");
Chris Lattner2c8569d2007-12-02 07:19:18 +0000134 std::string Msg = Type;
Chris Lattner0a14eee2008-11-18 07:04:44 +0000135 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID)
136 << Msg << S->getSourceRange();
Chris Lattner2c8569d2007-12-02 07:19:18 +0000137}
Chris Lattner58c3f9e2007-12-02 06:27:33 +0000138
Daniel Dunbar488e9932008-08-16 00:56:44 +0000139/// ErrorUnsupported - Print out an error that codegen doesn't support the
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000140/// specified decl yet.
Daniel Dunbar90df4b62008-09-04 03:43:08 +0000141void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type,
142 bool OmitOnError) {
143 if (OmitOnError && getDiags().hasErrorOccurred())
144 return;
Mike Stump1eb44332009-09-09 15:08:12 +0000145 unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error,
Daniel Dunbar56b80012009-02-06 19:18:03 +0000146 "cannot compile this %0 yet");
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000147 std::string Msg = Type;
Chris Lattner0a14eee2008-11-18 07:04:44 +0000148 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
Chris Lattnerc6fdc342008-01-12 07:05:38 +0000149}
150
Mike Stump1eb44332009-09-09 15:08:12 +0000151LangOptions::VisibilityMode
Daniel Dunbar04d40782009-04-14 06:00:08 +0000152CodeGenModule::getDeclVisibilityMode(const Decl *D) const {
153 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
154 if (VD->getStorageClass() == VarDecl::PrivateExtern)
155 return LangOptions::Hidden;
156
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000157 if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>()) {
Daniel Dunbar04d40782009-04-14 06:00:08 +0000158 switch (attr->getVisibility()) {
159 default: assert(0 && "Unknown visibility!");
Sean Huntcf807c42010-08-18 23:23:40 +0000160 case VisibilityAttr::Default:
Daniel Dunbar04d40782009-04-14 06:00:08 +0000161 return LangOptions::Default;
Sean Huntcf807c42010-08-18 23:23:40 +0000162 case VisibilityAttr::Hidden:
Daniel Dunbar04d40782009-04-14 06:00:08 +0000163 return LangOptions::Hidden;
Sean Huntcf807c42010-08-18 23:23:40 +0000164 case VisibilityAttr::Protected:
Daniel Dunbar04d40782009-04-14 06:00:08 +0000165 return LangOptions::Protected;
166 }
167 }
Douglas Gregor7cf84d62010-06-15 17:05:35 +0000168
Douglas Gregoraf896892010-06-21 18:41:26 +0000169 if (getLangOptions().CPlusPlus) {
170 // Entities subject to an explicit instantiation declaration get default
171 // visibility.
172 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
173 if (Function->getTemplateSpecializationKind()
174 == TSK_ExplicitInstantiationDeclaration)
175 return LangOptions::Default;
176 } else if (const ClassTemplateSpecializationDecl *ClassSpec
177 = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
178 if (ClassSpec->getSpecializationKind()
179 == TSK_ExplicitInstantiationDeclaration)
180 return LangOptions::Default;
181 } else if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(D)) {
182 if (Record->getTemplateSpecializationKind()
183 == TSK_ExplicitInstantiationDeclaration)
184 return LangOptions::Default;
185 } else if (const VarDecl *Var = dyn_cast<VarDecl>(D)) {
186 if (Var->isStaticDataMember() &&
187 (Var->getTemplateSpecializationKind()
188 == TSK_ExplicitInstantiationDeclaration))
189 return LangOptions::Default;
190 }
191
192 // If -fvisibility-inlines-hidden was provided, then inline C++ member
193 // functions get "hidden" visibility by default.
194 if (getLangOptions().InlineVisibilityHidden)
195 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
196 if (Method->isInlined())
197 return LangOptions::Hidden;
198 }
199
Eli Friedmanaa8b0d12010-08-05 06:57:20 +0000200 // If this decl is contained in a class, it should have the same visibility
201 // as the parent class.
Anders Carlsson39de84d2010-02-07 01:44:36 +0000202 if (const DeclContext *DC = D->getDeclContext())
Eli Friedmanaa8b0d12010-08-05 06:57:20 +0000203 if (DC->isRecord())
204 return getDeclVisibilityMode(cast<Decl>(DC));
Anders Carlsson39de84d2010-02-07 01:44:36 +0000205
Daniel Dunbar04d40782009-04-14 06:00:08 +0000206 return getLangOptions().getVisibilityMode();
207}
208
Mike Stump1eb44332009-09-09 15:08:12 +0000209void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
Daniel Dunbar04d40782009-04-14 06:00:08 +0000210 const Decl *D) const {
211 // Internal definitions always have default visibility.
Chris Lattnerdf102fc2009-04-14 05:27:13 +0000212 if (GV->hasLocalLinkage()) {
Daniel Dunbar7e714cd2009-04-10 20:26:50 +0000213 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
Daniel Dunbar6ab187a2009-04-07 05:48:37 +0000214 return;
Daniel Dunbar7e714cd2009-04-10 20:26:50 +0000215 }
Daniel Dunbar6ab187a2009-04-07 05:48:37 +0000216
Daniel Dunbar04d40782009-04-14 06:00:08 +0000217 switch (getDeclVisibilityMode(D)) {
Dan Gohman4f8d1232008-05-22 00:50:06 +0000218 default: assert(0 && "Unknown visibility!");
Daniel Dunbar04d40782009-04-14 06:00:08 +0000219 case LangOptions::Default:
220 return GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
221 case LangOptions::Hidden:
222 return GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
223 case LangOptions::Protected:
224 return GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);
Dan Gohman4f8d1232008-05-22 00:50:06 +0000225 }
226}
227
John McCallcbfe5022010-08-04 08:34:44 +0000228/// Set the symbol visibility of type information (vtable and RTTI)
229/// associated with the given type.
230void CodeGenModule::setTypeVisibility(llvm::GlobalValue *GV,
231 const CXXRecordDecl *RD,
232 bool IsForRTTI) const {
233 setGlobalVisibility(GV, RD);
234
John McCall279b5eb2010-08-12 23:36:15 +0000235 if (!CodeGenOpts.HiddenWeakVTables)
236 return;
237
John McCallcbfe5022010-08-04 08:34:44 +0000238 // We want to drop the visibility to hidden for weak type symbols.
239 // This isn't possible if there might be unresolved references
240 // elsewhere that rely on this symbol being visible.
241
John McCall7a536902010-08-05 20:39:18 +0000242 // This should be kept roughly in sync with setThunkVisibility
243 // in CGVTables.cpp.
244
John McCallcbfe5022010-08-04 08:34:44 +0000245 // Preconditions.
246 if (GV->getLinkage() != llvm::GlobalVariable::WeakODRLinkage ||
247 GV->getVisibility() != llvm::GlobalVariable::DefaultVisibility)
248 return;
249
250 // Don't override an explicit visibility attribute.
251 if (RD->hasAttr<VisibilityAttr>())
252 return;
253
254 switch (RD->getTemplateSpecializationKind()) {
255 // We have to disable the optimization if this is an EI definition
256 // because there might be EI declarations in other shared objects.
257 case TSK_ExplicitInstantiationDefinition:
258 case TSK_ExplicitInstantiationDeclaration:
259 return;
260
John McCall7a536902010-08-05 20:39:18 +0000261 // Every use of a non-template class's type information has to emit it.
John McCallcbfe5022010-08-04 08:34:44 +0000262 case TSK_Undeclared:
263 break;
264
John McCall7a536902010-08-05 20:39:18 +0000265 // In theory, implicit instantiations can ignore the possibility of
266 // an explicit instantiation declaration because there necessarily
267 // must be an EI definition somewhere with default visibility. In
268 // practice, it's possible to have an explicit instantiation for
269 // an arbitrary template class, and linkers aren't necessarily able
270 // to deal with mixed-visibility symbols.
271 case TSK_ExplicitSpecialization:
John McCallcbfe5022010-08-04 08:34:44 +0000272 case TSK_ImplicitInstantiation:
John McCall279b5eb2010-08-12 23:36:15 +0000273 if (!CodeGenOpts.HiddenWeakTemplateVTables)
John McCall7a536902010-08-05 20:39:18 +0000274 return;
John McCallcbfe5022010-08-04 08:34:44 +0000275 break;
276 }
277
278 // If there's a key function, there may be translation units
279 // that don't have the key function's definition. But ignore
280 // this if we're emitting RTTI under -fno-rtti.
281 if (!IsForRTTI || Features.RTTI)
282 if (Context.getKeyFunction(RD))
283 return;
284
285 // Otherwise, drop the visibility to hidden.
286 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
287}
288
Anders Carlsson793a9902010-06-22 16:05:32 +0000289llvm::StringRef CodeGenModule::getMangledName(GlobalDecl GD) {
290 const NamedDecl *ND = cast<NamedDecl>(GD.getDecl());
291
292 llvm::StringRef &Str = MangledDeclNames[GD.getCanonicalDecl()];
293 if (!Str.empty())
294 return Str;
295
296 if (!getMangleContext().shouldMangleDeclName(ND)) {
297 IdentifierInfo *II = ND->getIdentifier();
298 assert(II && "Attempt to mangle unnamed decl.");
299
300 Str = II->getName();
301 return Str;
302 }
303
304 llvm::SmallString<256> Buffer;
305 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND))
306 getMangleContext().mangleCXXCtor(D, GD.getCtorType(), Buffer);
307 else if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND))
308 getMangleContext().mangleCXXDtor(D, GD.getDtorType(), Buffer);
309 else if (const BlockDecl *BD = dyn_cast<BlockDecl>(ND))
Fariborz Jahanian564360b2010-06-24 00:08:06 +0000310 getMangleContext().mangleBlock(GD, BD, Buffer);
Anders Carlsson793a9902010-06-22 16:05:32 +0000311 else
312 getMangleContext().mangleName(ND, Buffer);
313
314 // Allocate space for the mangled name.
315 size_t Length = Buffer.size();
316 char *Name = MangledNamesAllocator.Allocate<char>(Length);
317 std::copy(Buffer.begin(), Buffer.end(), Name);
318
319 Str = llvm::StringRef(Name, Length);
320
321 return Str;
322}
323
Fariborz Jahanian564360b2010-06-24 00:08:06 +0000324void CodeGenModule::getMangledName(GlobalDecl GD, MangleBuffer &Buffer,
325 const BlockDecl *BD) {
326 getMangleContext().mangleBlock(GD, BD, Buffer.getBuffer());
Anders Carlsson9a8822b2010-06-09 02:36:32 +0000327}
328
John McCallf746aa62010-03-19 23:29:14 +0000329llvm::GlobalValue *CodeGenModule::GetGlobalValue(llvm::StringRef Name) {
330 return getModule().getNamedValue(Name);
Douglas Gregor5f2bfd42009-02-13 00:10:09 +0000331}
332
Chris Lattner6d397602008-03-14 17:18:18 +0000333/// AddGlobalCtor - Add a function to the list that will be called before
334/// main() runs.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000335void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) {
Daniel Dunbar49988882009-01-13 02:25:00 +0000336 // FIXME: Type coercion of void()* types.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000337 GlobalCtors.push_back(std::make_pair(Ctor, Priority));
Chris Lattner6d397602008-03-14 17:18:18 +0000338}
339
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000340/// AddGlobalDtor - Add a function to the list that will be called
341/// when the module is unloaded.
342void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) {
Daniel Dunbar49988882009-01-13 02:25:00 +0000343 // FIXME: Type coercion of void()* types.
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000344 GlobalDtors.push_back(std::make_pair(Dtor, Priority));
345}
346
347void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) {
348 // Ctor function type is void()*.
349 llvm::FunctionType* CtorFTy =
Mike Stump1eb44332009-09-09 15:08:12 +0000350 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000351 std::vector<const llvm::Type*>(),
352 false);
Owen Anderson96e0fc72009-07-29 22:16:19 +0000353 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000354
355 // Get the type of a ctor entry, { i32, void ()* }.
Mike Stump1eb44332009-09-09 15:08:12 +0000356 llvm::StructType* CtorStructTy =
357 llvm::StructType::get(VMContext, llvm::Type::getInt32Ty(VMContext),
Owen Anderson96e0fc72009-07-29 22:16:19 +0000358 llvm::PointerType::getUnqual(CtorFTy), NULL);
Chris Lattner6d397602008-03-14 17:18:18 +0000359
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000360 // Construct the constructor and destructor arrays.
361 std::vector<llvm::Constant*> Ctors;
362 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
363 std::vector<llvm::Constant*> S;
Mike Stump1eb44332009-09-09 15:08:12 +0000364 S.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext),
Owen Anderson0032b272009-08-13 21:57:51 +0000365 I->second, false));
Owen Anderson3c4972d2009-07-29 18:54:39 +0000366 S.push_back(llvm::ConstantExpr::getBitCast(I->first, CtorPFTy));
Owen Anderson08e25242009-07-27 22:29:56 +0000367 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S));
Chris Lattner6d397602008-03-14 17:18:18 +0000368 }
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000369
370 if (!Ctors.empty()) {
Owen Anderson96e0fc72009-07-29 22:16:19 +0000371 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size());
Owen Anderson1c431b32009-07-08 19:05:04 +0000372 new llvm::GlobalVariable(TheModule, AT, false,
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000373 llvm::GlobalValue::AppendingLinkage,
Owen Anderson7db6d832009-07-28 18:33:04 +0000374 llvm::ConstantArray::get(AT, Ctors),
Owen Anderson1c431b32009-07-08 19:05:04 +0000375 GlobalName);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +0000376 }
Chris Lattner6d397602008-03-14 17:18:18 +0000377}
378
Nate Begeman532485c2008-04-18 23:43:57 +0000379void CodeGenModule::EmitAnnotations() {
380 if (Annotations.empty())
381 return;
382
383 // Create a new global variable for the ConstantStruct in the Module.
384 llvm::Constant *Array =
Owen Anderson96e0fc72009-07-29 22:16:19 +0000385 llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(),
Nate Begeman532485c2008-04-18 23:43:57 +0000386 Annotations.size()),
387 Annotations);
Mike Stump1eb44332009-09-09 15:08:12 +0000388 llvm::GlobalValue *gv =
389 new llvm::GlobalVariable(TheModule, Array->getType(), false,
390 llvm::GlobalValue::AppendingLinkage, Array,
Owen Anderson1c431b32009-07-08 19:05:04 +0000391 "llvm.global.annotations");
Nate Begeman532485c2008-04-18 23:43:57 +0000392 gv->setSection("llvm.metadata");
393}
394
John McCalld46f9852010-02-19 01:32:20 +0000395llvm::GlobalValue::LinkageTypes
396CodeGenModule::getFunctionLinkage(const FunctionDecl *D) {
Argyrios Kyrtzidis90e99a82010-07-29 18:15:58 +0000397 GVALinkage Linkage = getContext().GetGVALinkageForFunction(D);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000398
Chris Lattnerf81530652010-06-30 16:58:07 +0000399 if (Linkage == GVA_Internal)
John McCalld46f9852010-02-19 01:32:20 +0000400 return llvm::Function::InternalLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000401
402 if (D->hasAttr<DLLExportAttr>())
John McCalld46f9852010-02-19 01:32:20 +0000403 return llvm::Function::DLLExportLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000404
405 if (D->hasAttr<WeakAttr>())
John McCalld46f9852010-02-19 01:32:20 +0000406 return llvm::Function::WeakAnyLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000407
408 // In C99 mode, 'inline' functions are guaranteed to have a strong
409 // definition somewhere else, so we can use available_externally linkage.
410 if (Linkage == GVA_C99Inline)
John McCalld46f9852010-02-19 01:32:20 +0000411 return llvm::Function::AvailableExternallyLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000412
413 // In C++, the compiler has to emit a definition in every translation unit
414 // that references the function. We should use linkonce_odr because
415 // a) if all references in this translation unit are optimized away, we
416 // don't need to codegen it. b) if the function persists, it needs to be
417 // merged with other definitions. c) C++ has the ODR, so we know the
418 // definition is dependable.
419 if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation)
John McCalld46f9852010-02-19 01:32:20 +0000420 return llvm::Function::LinkOnceODRLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000421
422 // An explicit instantiation of a template has weak linkage, since
423 // explicit instantiations can occur in multiple translation units
424 // and must all be equivalent. However, we are not allowed to
425 // throw away these explicit instantiations.
426 if (Linkage == GVA_ExplicitTemplateInstantiation)
Douglas Gregor8f51a4f2010-03-13 18:23:07 +0000427 return llvm::Function::WeakODRLinkage;
Chris Lattnerf81530652010-06-30 16:58:07 +0000428
429 // Otherwise, we have strong external linkage.
430 assert(Linkage == GVA_StrongExternal);
431 return llvm::Function::ExternalLinkage;
John McCalld46f9852010-02-19 01:32:20 +0000432}
Nuno Lopesd4cbda62008-06-08 15:45:52 +0000433
John McCalld46f9852010-02-19 01:32:20 +0000434
435/// SetFunctionDefinitionAttributes - Set attributes for a global.
436///
437/// FIXME: This is currently only done for aliases and functions, but not for
438/// variables (these details are set in EmitGlobalVarDefinition for variables).
439void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D,
440 llvm::GlobalValue *GV) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000441 SetCommonAttributes(D, GV);
Nuno Lopesd4cbda62008-06-08 15:45:52 +0000442}
443
Daniel Dunbar7dbd8192009-04-14 07:08:30 +0000444void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D,
Mike Stump1eb44332009-09-09 15:08:12 +0000445 const CGFunctionInfo &Info,
Daniel Dunbar7dbd8192009-04-14 07:08:30 +0000446 llvm::Function *F) {
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000447 unsigned CallingConv;
Devang Patel761d7f72008-09-25 21:02:23 +0000448 AttributeListType AttributeList;
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000449 ConstructAttributeList(Info, D, AttributeList, CallingConv);
Devang Patel761d7f72008-09-25 21:02:23 +0000450 F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(),
Daniel Dunbarca6408c2009-09-12 00:59:20 +0000451 AttributeList.size()));
452 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000453}
454
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000455void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
456 llvm::Function *F) {
Daniel Dunbar74ac74a2009-03-02 04:58:03 +0000457 if (!Features.Exceptions && !Features.ObjCNonFragileABI)
Mike Stump1eb44332009-09-09 15:08:12 +0000458 F->addFnAttr(llvm::Attribute::NoUnwind);
Daniel Dunbaraf668b02008-10-28 00:17:57 +0000459
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000460 if (D->hasAttr<AlwaysInlineAttr>())
Daniel Dunbaraf668b02008-10-28 00:17:57 +0000461 F->addFnAttr(llvm::Attribute::AlwaysInline);
Mike Stump1eb44332009-09-09 15:08:12 +0000462
Mike Stump1feade82009-08-26 22:31:08 +0000463 if (D->hasAttr<NoInlineAttr>())
Anders Carlsson81ebbde2009-02-19 19:22:11 +0000464 F->addFnAttr(llvm::Attribute::NoInline);
Mike Stumpf55314d2009-10-05 21:58:44 +0000465
Anders Carlssonfd015352009-11-16 16:56:03 +0000466 if (Features.getStackProtectorMode() == LangOptions::SSPOn)
467 F->addFnAttr(llvm::Attribute::StackProtect);
468 else if (Features.getStackProtectorMode() == LangOptions::SSPReq)
469 F->addFnAttr(llvm::Attribute::StackProtectReq);
470
Sean Huntcf807c42010-08-18 23:23:40 +0000471 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
472 if (alignment)
473 F->setAlignment(alignment);
474
Mike Stumpfb51ddf2009-10-05 22:49:20 +0000475 // C++ ABI requires 2-byte alignment for member functions.
Mike Stumpbd6dbd12009-10-05 23:08:21 +0000476 if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
477 F->setAlignment(2);
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000478}
479
Mike Stump1eb44332009-09-09 15:08:12 +0000480void CodeGenModule::SetCommonAttributes(const Decl *D,
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000481 llvm::GlobalValue *GV) {
482 setGlobalVisibility(GV, D);
483
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000484 if (D->hasAttr<UsedAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000485 AddUsedGlobal(GV);
486
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000487 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000488 GV->setSection(SA->getName());
Anton Korobeynikov82d0a412010-01-10 12:58:08 +0000489
490 getTargetCodeGenInfo().SetTargetAttributes(D, GV, *this);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000491}
492
Daniel Dunbar0e4f40e2009-04-17 00:48:04 +0000493void CodeGenModule::SetInternalFunctionAttributes(const Decl *D,
494 llvm::Function *F,
495 const CGFunctionInfo &FI) {
496 SetLLVMFunctionAttributes(D, FI, F);
497 SetLLVMFunctionAttributesForDefinition(D, F);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000498
499 F->setLinkage(llvm::Function::InternalLinkage);
500
Daniel Dunbar0e4f40e2009-04-17 00:48:04 +0000501 SetCommonAttributes(D, F);
Daniel Dunbarf80519b2008-09-04 23:41:35 +0000502}
503
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000504void CodeGenModule::SetFunctionAttributes(GlobalDecl GD,
Eli Friedmanc6c14d12009-05-26 01:22:57 +0000505 llvm::Function *F,
506 bool IsIncompleteFunction) {
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000507 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
508
Eli Friedmanc6c14d12009-05-26 01:22:57 +0000509 if (!IsIncompleteFunction)
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000510 SetLLVMFunctionAttributes(FD, getTypes().getFunctionInfo(GD), F);
Mike Stump1eb44332009-09-09 15:08:12 +0000511
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000512 // Only a few attributes are set on declarations; these may later be
513 // overridden by a definition.
Mike Stump1eb44332009-09-09 15:08:12 +0000514
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000515 if (FD->hasAttr<DLLImportAttr>()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000516 F->setLinkage(llvm::Function::DLLImportLinkage);
Mike Stump1eb44332009-09-09 15:08:12 +0000517 } else if (FD->hasAttr<WeakAttr>() ||
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000518 FD->hasAttr<WeakImportAttr>()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000519 // "extern_weak" is overloaded in LLVM; we probably should have
Mike Stump1eb44332009-09-09 15:08:12 +0000520 // separate linkage types for this.
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000521 F->setLinkage(llvm::Function::ExternalWeakLinkage);
522 } else {
Mike Stump1eb44332009-09-09 15:08:12 +0000523 F->setLinkage(llvm::Function::ExternalLinkage);
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000524 }
525
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000526 if (const SectionAttr *SA = FD->getAttr<SectionAttr>())
Daniel Dunbar7c65e992009-04-14 08:05:55 +0000527 F->setSection(SA->getName());
Daniel Dunbar219df662008-09-08 23:44:31 +0000528}
529
Daniel Dunbar02698712009-02-13 20:29:50 +0000530void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) {
Mike Stump1eb44332009-09-09 15:08:12 +0000531 assert(!GV->isDeclaration() &&
Daniel Dunbar02698712009-02-13 20:29:50 +0000532 "Only globals with definition can force usage.");
Chris Lattner35f38a22009-03-31 22:37:52 +0000533 LLVMUsed.push_back(GV);
Daniel Dunbar02698712009-02-13 20:29:50 +0000534}
535
536void CodeGenModule::EmitLLVMUsed() {
537 // Don't create llvm.used if there is no need.
Chris Lattnerad64e022009-07-17 23:57:13 +0000538 if (LLVMUsed.empty())
Daniel Dunbar02698712009-02-13 20:29:50 +0000539 return;
540
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +0000541 const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext);
Mike Stump1eb44332009-09-09 15:08:12 +0000542
Chris Lattner35f38a22009-03-31 22:37:52 +0000543 // Convert LLVMUsed to what ConstantArray needs.
544 std::vector<llvm::Constant*> UsedArray;
545 UsedArray.resize(LLVMUsed.size());
546 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) {
Mike Stump1eb44332009-09-09 15:08:12 +0000547 UsedArray[i] =
548 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]),
Owen Andersona1cf15f2009-07-14 23:10:40 +0000549 i8PTy);
Chris Lattner35f38a22009-03-31 22:37:52 +0000550 }
Mike Stump1eb44332009-09-09 15:08:12 +0000551
Fariborz Jahanianc38e9af2009-06-23 21:47:46 +0000552 if (UsedArray.empty())
553 return;
Owen Anderson96e0fc72009-07-29 22:16:19 +0000554 llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, UsedArray.size());
Mike Stump1eb44332009-09-09 15:08:12 +0000555
556 llvm::GlobalVariable *GV =
557 new llvm::GlobalVariable(getModule(), ATy, false,
Daniel Dunbar02698712009-02-13 20:29:50 +0000558 llvm::GlobalValue::AppendingLinkage,
Owen Anderson7db6d832009-07-28 18:33:04 +0000559 llvm::ConstantArray::get(ATy, UsedArray),
Owen Anderson1c431b32009-07-08 19:05:04 +0000560 "llvm.used");
Daniel Dunbar02698712009-02-13 20:29:50 +0000561
562 GV->setSection("llvm.metadata");
563}
564
565void CodeGenModule::EmitDeferred() {
Chris Lattner67b00522009-03-21 09:44:56 +0000566 // Emit code for any potentially referenced deferred decls. Since a
567 // previously unused static decl may become used during the generation of code
568 // for a static function, iterate until no changes are made.
Rafael Espindolabbf58bb2010-03-10 02:19:29 +0000569
Anders Carlsson046c2942010-04-17 20:15:18 +0000570 while (!DeferredDeclsToEmit.empty() || !DeferredVTables.empty()) {
571 if (!DeferredVTables.empty()) {
572 const CXXRecordDecl *RD = DeferredVTables.back();
573 DeferredVTables.pop_back();
574 getVTables().GenerateClassData(getVTableLinkage(RD), RD);
Rafael Espindolabbf58bb2010-03-10 02:19:29 +0000575 continue;
576 }
577
Anders Carlsson2a131fb2009-05-05 04:44:02 +0000578 GlobalDecl D = DeferredDeclsToEmit.back();
Chris Lattner67b00522009-03-21 09:44:56 +0000579 DeferredDeclsToEmit.pop_back();
580
John McCallc76702c2010-05-27 01:45:30 +0000581 // Check to see if we've already emitted this. This is necessary
582 // for a couple of reasons: first, decls can end up in the
583 // deferred-decls queue multiple times, and second, decls can end
584 // up with definitions in unusual ways (e.g. by an extern inline
585 // function acquiring a strong function redefinition). Just
586 // ignore these cases.
587 //
588 // TODO: That said, looking this up multiple times is very wasteful.
Anders Carlsson9a20d552010-06-22 16:16:50 +0000589 llvm::StringRef Name = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +0000590 llvm::GlobalValue *CGRef = GetGlobalValue(Name);
Chris Lattner67b00522009-03-21 09:44:56 +0000591 assert(CGRef && "Deferred decl wasn't referenced?");
Mike Stump1eb44332009-09-09 15:08:12 +0000592
Chris Lattner67b00522009-03-21 09:44:56 +0000593 if (!CGRef->isDeclaration())
594 continue;
Mike Stump1eb44332009-09-09 15:08:12 +0000595
John McCallc76702c2010-05-27 01:45:30 +0000596 // GlobalAlias::isDeclaration() defers to the aliasee, but for our
597 // purposes an alias counts as a definition.
598 if (isa<llvm::GlobalAlias>(CGRef))
599 continue;
600
Chris Lattner67b00522009-03-21 09:44:56 +0000601 // Otherwise, emit the definition and move on to the next one.
602 EmitGlobalDefinition(D);
603 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000604}
605
Mike Stump1eb44332009-09-09 15:08:12 +0000606/// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000607/// annotation information for a given GlobalValue. The annotation struct is
Mike Stump1eb44332009-09-09 15:08:12 +0000608/// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the
609/// GlobalValue being annotated. The second field is the constant string
610/// created from the AnnotateAttr's annotation. The third field is a constant
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000611/// string containing the name of the translation unit. The fourth field is
612/// the line number in the file of the annotated value declaration.
613///
614/// FIXME: this does not unique the annotation string constants, as llvm-gcc
615/// appears to.
616///
Mike Stump1eb44332009-09-09 15:08:12 +0000617llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000618 const AnnotateAttr *AA,
619 unsigned LineNo) {
620 llvm::Module *M = &getModule();
621
622 // get [N x i8] constants for the annotation string, and the filename string
623 // which are the 2nd and 3rd elements of the global annotation structure.
Benjamin Kramer3c0ef8c2009-10-13 10:07:13 +0000624 const llvm::Type *SBP = llvm::Type::getInt8PtrTy(VMContext);
Mike Stump1eb44332009-09-09 15:08:12 +0000625 llvm::Constant *anno = llvm::ConstantArray::get(VMContext,
Owen Anderson0032b272009-08-13 21:57:51 +0000626 AA->getAnnotation(), true);
627 llvm::Constant *unit = llvm::ConstantArray::get(VMContext,
628 M->getModuleIdentifier(),
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000629 true);
630
631 // Get the two global values corresponding to the ConstantArrays we just
632 // created to hold the bytes of the strings.
Mike Stump1eb44332009-09-09 15:08:12 +0000633 llvm::GlobalValue *annoGV =
Chris Lattner95b851e2009-07-16 05:03:48 +0000634 new llvm::GlobalVariable(*M, anno->getType(), false,
635 llvm::GlobalValue::PrivateLinkage, anno,
636 GV->getName());
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000637 // translation unit name string, emitted into the llvm.metadata section.
638 llvm::GlobalValue *unitGV =
Chris Lattner95b851e2009-07-16 05:03:48 +0000639 new llvm::GlobalVariable(*M, unit->getType(), false,
Mike Stump1eb44332009-09-09 15:08:12 +0000640 llvm::GlobalValue::PrivateLinkage, unit,
Chris Lattner95b851e2009-07-16 05:03:48 +0000641 ".str");
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000642
Daniel Dunbar57d5cee2009-04-14 22:41:13 +0000643 // Create the ConstantStruct for the global annotation.
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000644 llvm::Constant *Fields[4] = {
Owen Anderson3c4972d2009-07-29 18:54:39 +0000645 llvm::ConstantExpr::getBitCast(GV, SBP),
646 llvm::ConstantExpr::getBitCast(annoGV, SBP),
647 llvm::ConstantExpr::getBitCast(unitGV, SBP),
Owen Anderson0032b272009-08-13 21:57:51 +0000648 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), LineNo)
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000649 };
Owen Anderson47a434f2009-08-05 23:18:46 +0000650 return llvm::ConstantStruct::get(VMContext, Fields, 4, false);
Nate Begeman8bd4afe2008-04-19 04:17:09 +0000651}
652
Argyrios Kyrtzidisa6d6af32010-07-27 22:37:14 +0000653bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) {
Argyrios Kyrtzidis90e99a82010-07-29 18:15:58 +0000654 // Never defer when EmitAllDecls is specified.
655 if (Features.EmitAllDecls)
Daniel Dunbar73241df2009-02-13 21:18:01 +0000656 return false;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000657
Argyrios Kyrtzidis4ac7c0b2010-07-29 20:08:05 +0000658 return !getContext().DeclMustBeEmitted(Global);
Daniel Dunbar73241df2009-02-13 21:18:01 +0000659}
660
Rafael Espindola6a836702010-03-04 18:17:24 +0000661llvm::Constant *CodeGenModule::GetWeakRefReference(const ValueDecl *VD) {
662 const AliasAttr *AA = VD->getAttr<AliasAttr>();
663 assert(AA && "No alias?");
664
665 const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
666
Rafael Espindola6a836702010-03-04 18:17:24 +0000667 // See if there is already something with the target's name in the module.
John McCallf746aa62010-03-19 23:29:14 +0000668 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
Rafael Espindola6a836702010-03-04 18:17:24 +0000669
670 llvm::Constant *Aliasee;
671 if (isa<llvm::FunctionType>(DeclTy))
John McCallf746aa62010-03-19 23:29:14 +0000672 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl());
Rafael Espindola6a836702010-03-04 18:17:24 +0000673 else
John McCallf746aa62010-03-19 23:29:14 +0000674 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Rafael Espindola6a836702010-03-04 18:17:24 +0000675 llvm::PointerType::getUnqual(DeclTy), 0);
676 if (!Entry) {
677 llvm::GlobalValue* F = cast<llvm::GlobalValue>(Aliasee);
678 F->setLinkage(llvm::Function::ExternalWeakLinkage);
679 WeakRefReferences.insert(F);
680 }
681
682 return Aliasee;
683}
684
Chris Lattnerb4880ba2009-05-12 21:21:08 +0000685void CodeGenModule::EmitGlobal(GlobalDecl GD) {
Anders Carlsson4a6835e2009-09-10 23:38:47 +0000686 const ValueDecl *Global = cast<ValueDecl>(GD.getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +0000687
Rafael Espindola6a836702010-03-04 18:17:24 +0000688 // Weak references don't produce any output by themselves.
689 if (Global->hasAttr<WeakRefAttr>())
690 return;
691
Chris Lattnerbd532712009-03-22 21:47:11 +0000692 // If this is an alias definition (which otherwise looks like a declaration)
693 // emit it now.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000694 if (Global->hasAttr<AliasAttr>())
John McCallf746aa62010-03-19 23:29:14 +0000695 return EmitAliasDefinition(GD);
Daniel Dunbar219df662008-09-08 23:44:31 +0000696
Chris Lattner67b00522009-03-21 09:44:56 +0000697 // Ignore declarations, they will be emitted on their first use.
Daniel Dunbar5e1e1f92009-03-19 08:27:24 +0000698 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) {
Daniel Dunbar754b9fb2010-07-16 00:00:19 +0000699 if (FD->getIdentifier()) {
700 llvm::StringRef Name = FD->getName();
701 if (Name == "_Block_object_assign") {
702 BlockObjectAssignDecl = FD;
703 } else if (Name == "_Block_object_dispose") {
704 BlockObjectDisposeDecl = FD;
705 }
706 }
707
Daniel Dunbar73241df2009-02-13 21:18:01 +0000708 // Forward declarations are emitted lazily on first use.
709 if (!FD->isThisDeclarationADefinition())
710 return;
Daniel Dunbar02698712009-02-13 20:29:50 +0000711 } else {
712 const VarDecl *VD = cast<VarDecl>(Global);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000713 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
714
Daniel Dunbar754b9fb2010-07-16 00:00:19 +0000715 if (VD->getIdentifier()) {
716 llvm::StringRef Name = VD->getName();
717 if (Name == "_NSConcreteGlobalBlock") {
718 NSConcreteGlobalBlockDecl = VD;
719 } else if (Name == "_NSConcreteStackBlock") {
720 NSConcreteStackBlockDecl = VD;
721 }
722 }
723
724
Douglas Gregora9a55c02010-02-06 05:15:45 +0000725 if (VD->isThisDeclarationADefinition() != VarDecl::Definition)
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000726 return;
Nate Begeman4c13b7a2008-04-20 06:29:50 +0000727 }
728
Chris Lattner67b00522009-03-21 09:44:56 +0000729 // Defer code generation when possible if this is a static definition, inline
730 // function etc. These we only want to emit if they are used.
Chris Lattner4357a822010-04-13 17:39:09 +0000731 if (!MayDeferGeneration(Global)) {
732 // Emit the definition if it can't be deferred.
733 EmitGlobalDefinition(GD);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000734 return;
735 }
John McCallbf40cb52010-07-15 23:40:35 +0000736
737 // If we're deferring emission of a C++ variable with an
738 // initializer, remember the order in which it appeared in the file.
739 if (getLangOptions().CPlusPlus && isa<VarDecl>(Global) &&
740 cast<VarDecl>(Global)->hasInit()) {
741 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
742 CXXGlobalInits.push_back(0);
743 }
Chris Lattner4357a822010-04-13 17:39:09 +0000744
745 // If the value has already been used, add it directly to the
746 // DeferredDeclsToEmit list.
Anders Carlsson9a20d552010-06-22 16:16:50 +0000747 llvm::StringRef MangledName = getMangledName(GD);
Chris Lattner4357a822010-04-13 17:39:09 +0000748 if (GetGlobalValue(MangledName))
749 DeferredDeclsToEmit.push_back(GD);
750 else {
751 // Otherwise, remember that we saw a deferred decl with this name. The
752 // first use of the mangled name will cause it to move into
753 // DeferredDeclsToEmit.
754 DeferredDecls[MangledName] = GD;
755 }
Nate Begeman4c13b7a2008-04-20 06:29:50 +0000756}
757
Chris Lattnerb4880ba2009-05-12 21:21:08 +0000758void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) {
Anders Carlsson4a6835e2009-09-10 23:38:47 +0000759 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Mike Stump1eb44332009-09-09 15:08:12 +0000760
Dan Gohmancb421fa2010-04-19 16:39:44 +0000761 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
Anders Carlsson8e2efcc2009-10-27 14:32:27 +0000762 Context.getSourceManager(),
763 "Generating code for declaration");
764
Douglas Gregor44eac332010-07-13 06:02:28 +0000765 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
766 // At -O0, don't generate IR for functions with available_externally
767 // linkage.
Douglas Gregor7feaeee2010-07-15 22:58:18 +0000768 if (CodeGenOpts.OptimizationLevel == 0 &&
769 !Function->hasAttr<AlwaysInlineAttr>() &&
Douglas Gregor44eac332010-07-13 06:02:28 +0000770 getFunctionLinkage(Function)
771 == llvm::Function::AvailableExternallyLinkage)
772 return;
Anders Carlsson7270ee42010-03-23 04:31:31 +0000773
Douglas Gregor44eac332010-07-13 06:02:28 +0000774 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
775 if (Method->isVirtual())
776 getVTables().EmitThunks(GD);
777
778 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(Method))
779 return EmitCXXConstructor(CD, GD.getCtorType());
Chris Lattner4357a822010-04-13 17:39:09 +0000780
Douglas Gregor44eac332010-07-13 06:02:28 +0000781 if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(Method))
782 return EmitCXXDestructor(DD, GD.getDtorType());
783 }
Chris Lattnerb5e81562010-04-13 17:57:11 +0000784
Chris Lattnerb5e81562010-04-13 17:57:11 +0000785 return EmitGlobalFunctionDefinition(GD);
Douglas Gregor44eac332010-07-13 06:02:28 +0000786 }
Chris Lattnerb5e81562010-04-13 17:57:11 +0000787
788 if (const VarDecl *VD = dyn_cast<VarDecl>(D))
789 return EmitGlobalVarDefinition(VD);
Chris Lattner4357a822010-04-13 17:39:09 +0000790
791 assert(0 && "Invalid argument to EmitGlobalDefinition()");
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000792}
793
Chris Lattner74391b42009-03-22 21:03:39 +0000794/// GetOrCreateLLVMFunction - If the specified mangled name is not in the
795/// module, create and return an llvm Function with the specified type. If there
796/// is something in the module with the specified name, return it potentially
797/// bitcasted to the right type.
798///
799/// If D is non-null, it specifies a decl that correspond to this. This is used
800/// to set the attributes on the function when it is first created.
John McCallf746aa62010-03-19 23:29:14 +0000801llvm::Constant *
802CodeGenModule::GetOrCreateLLVMFunction(llvm::StringRef MangledName,
803 const llvm::Type *Ty,
804 GlobalDecl D) {
Chris Lattner0558e792009-03-21 09:25:43 +0000805 // Lookup the entry, lazily creating it if necessary.
John McCallf746aa62010-03-19 23:29:14 +0000806 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner0558e792009-03-21 09:25:43 +0000807 if (Entry) {
Rafael Espindola6a836702010-03-04 18:17:24 +0000808 if (WeakRefReferences.count(Entry)) {
809 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl());
810 if (FD && !FD->hasAttr<WeakAttr>())
Anders Carlsson7270ee42010-03-23 04:31:31 +0000811 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola6a836702010-03-04 18:17:24 +0000812
813 WeakRefReferences.erase(Entry);
814 }
815
Chris Lattner0558e792009-03-21 09:25:43 +0000816 if (Entry->getType()->getElementType() == Ty)
817 return Entry;
Mike Stump1eb44332009-09-09 15:08:12 +0000818
Chris Lattner0558e792009-03-21 09:25:43 +0000819 // Make sure the result is of the correct type.
Owen Anderson96e0fc72009-07-29 22:16:19 +0000820 const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
Owen Anderson3c4972d2009-07-29 18:54:39 +0000821 return llvm::ConstantExpr::getBitCast(Entry, PTy);
Chris Lattner0558e792009-03-21 09:25:43 +0000822 }
Mike Stump1eb44332009-09-09 15:08:12 +0000823
Eli Friedman654ad402009-11-09 05:07:37 +0000824 // This function doesn't have a complete type (for example, the return
825 // type is an incomplete struct). Use a fake type instead, and make
826 // sure not to try to set attributes.
827 bool IsIncompleteFunction = false;
John McCall784f2112010-04-28 00:00:30 +0000828
829 const llvm::FunctionType *FTy;
830 if (isa<llvm::FunctionType>(Ty)) {
831 FTy = cast<llvm::FunctionType>(Ty);
832 } else {
833 FTy = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),
834 std::vector<const llvm::Type*>(), false);
Eli Friedman654ad402009-11-09 05:07:37 +0000835 IsIncompleteFunction = true;
836 }
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000837
John McCall784f2112010-04-28 00:00:30 +0000838 llvm::Function *F = llvm::Function::Create(FTy,
Eli Friedman654ad402009-11-09 05:07:37 +0000839 llvm::Function::ExternalLinkage,
John McCallf746aa62010-03-19 23:29:14 +0000840 MangledName, &getModule());
841 assert(F->getName() == MangledName && "name was uniqued!");
Eli Friedman654ad402009-11-09 05:07:37 +0000842 if (D.getDecl())
Anders Carlssonb2bcf1c2010-02-06 02:44:09 +0000843 SetFunctionAttributes(D, F, IsIncompleteFunction);
Eli Friedman654ad402009-11-09 05:07:37 +0000844
Chris Lattner67b00522009-03-21 09:44:56 +0000845 // This is the first use or definition of a mangled name. If there is a
846 // deferred decl with this name, remember that we need to emit it at the end
847 // of the file.
John McCallf746aa62010-03-19 23:29:14 +0000848 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner67b00522009-03-21 09:44:56 +0000849 if (DDI != DeferredDecls.end()) {
850 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
851 // list, and remove it from DeferredDecls (since we don't need it anymore).
852 DeferredDeclsToEmit.push_back(DDI->second);
853 DeferredDecls.erase(DDI);
Chris Lattnerb4880ba2009-05-12 21:21:08 +0000854 } else if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl())) {
Chris Lattner0c337ed2009-05-12 21:02:27 +0000855 // If this the first reference to a C++ inline function in a class, queue up
856 // the deferred function body for emission. These are not seen as
857 // top-level declarations.
Chris Lattnerb4880ba2009-05-12 21:21:08 +0000858 if (FD->isThisDeclarationADefinition() && MayDeferGeneration(FD))
859 DeferredDeclsToEmit.push_back(D);
Fariborz Jahanianc7ff8e12009-07-30 23:22:00 +0000860 // A called constructor which has no definition or declaration need be
861 // synthesized.
862 else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) {
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +0000863 if (CD->isImplicit()) {
Benjamin Kramerd3a344c2010-03-06 09:07:19 +0000864 assert(CD->isUsed() && "Sema doesn't consider constructor as used.");
Eli Friedman15233e52009-11-26 07:40:08 +0000865 DeferredDeclsToEmit.push_back(D);
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +0000866 }
Eli Friedman15233e52009-11-26 07:40:08 +0000867 } else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(FD)) {
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +0000868 if (DD->isImplicit()) {
Benjamin Kramerd3a344c2010-03-06 09:07:19 +0000869 assert(DD->isUsed() && "Sema doesn't consider destructor as used.");
Eli Friedman15233e52009-11-26 07:40:08 +0000870 DeferredDeclsToEmit.push_back(D);
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +0000871 }
Eli Friedman15233e52009-11-26 07:40:08 +0000872 } else if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +0000873 if (MD->isCopyAssignment() && MD->isImplicit()) {
Benjamin Kramerd3a344c2010-03-06 09:07:19 +0000874 assert(MD->isUsed() && "Sema doesn't consider CopyAssignment as used.");
Fariborz Jahanianc7ff8e12009-07-30 23:22:00 +0000875 DeferredDeclsToEmit.push_back(D);
Rafael Espindola7b9a5aa2010-03-02 21:28:26 +0000876 }
Fariborz Jahanianc7ff8e12009-07-30 23:22:00 +0000877 }
Chris Lattner67b00522009-03-21 09:44:56 +0000878 }
Mike Stump1eb44332009-09-09 15:08:12 +0000879
John McCall784f2112010-04-28 00:00:30 +0000880 // Make sure the result is of the requested type.
881 if (!IsIncompleteFunction) {
882 assert(F->getType()->getElementType() == Ty);
883 return F;
884 }
885
886 const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
887 return llvm::ConstantExpr::getBitCast(F, PTy);
Chris Lattner0558e792009-03-21 09:25:43 +0000888}
889
Chris Lattner74391b42009-03-22 21:03:39 +0000890/// GetAddrOfFunction - Return the address of the given function. If Ty is
891/// non-null, then this function will use the specified type if it has to
892/// create it (this occurs when we see a definition of the function).
Chris Lattnerb4880ba2009-05-12 21:21:08 +0000893llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD,
Chris Lattner74391b42009-03-22 21:03:39 +0000894 const llvm::Type *Ty) {
895 // If there was no specific requested type, just convert it now.
896 if (!Ty)
Anders Carlsson4a6835e2009-09-10 23:38:47 +0000897 Ty = getTypes().ConvertType(cast<ValueDecl>(GD.getDecl())->getType());
Chris Lattnerbcaedae2010-06-30 19:14:05 +0000898
Anders Carlsson9a20d552010-06-22 16:16:50 +0000899 llvm::StringRef MangledName = getMangledName(GD);
John McCallf746aa62010-03-19 23:29:14 +0000900 return GetOrCreateLLVMFunction(MangledName, Ty, GD);
Chris Lattner74391b42009-03-22 21:03:39 +0000901}
Eli Friedman77ba7082008-05-30 19:50:47 +0000902
Chris Lattner74391b42009-03-22 21:03:39 +0000903/// CreateRuntimeFunction - Create a new runtime function with the specified
904/// type and name.
905llvm::Constant *
906CodeGenModule::CreateRuntimeFunction(const llvm::FunctionType *FTy,
John McCallf746aa62010-03-19 23:29:14 +0000907 llvm::StringRef Name) {
Chris Lattnerb4880ba2009-05-12 21:21:08 +0000908 return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl());
Chris Lattner74391b42009-03-22 21:03:39 +0000909}
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000910
Eli Friedman20e098b2009-12-11 21:23:03 +0000911static bool DeclIsConstantGlobal(ASTContext &Context, const VarDecl *D) {
John McCall88786862010-02-08 21:46:50 +0000912 if (!D->getType().isConstant(Context) && !D->getType()->isReferenceType())
Eli Friedman20e098b2009-12-11 21:23:03 +0000913 return false;
914 if (Context.getLangOptions().CPlusPlus &&
915 Context.getBaseElementType(D->getType())->getAs<RecordType>()) {
916 // FIXME: We should do something fancier here!
917 return false;
918 }
919 return true;
920}
921
Chris Lattner74391b42009-03-22 21:03:39 +0000922/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
923/// create and return an llvm GlobalVariable with the specified type. If there
924/// is something in the module with the specified name, return it potentially
925/// bitcasted to the right type.
926///
927/// If D is non-null, it specifies a decl that correspond to this. This is used
928/// to set the attributes on the global when it is first created.
John McCallf746aa62010-03-19 23:29:14 +0000929llvm::Constant *
930CodeGenModule::GetOrCreateLLVMGlobal(llvm::StringRef MangledName,
931 const llvm::PointerType *Ty,
932 const VarDecl *D) {
Daniel Dunbar3c827a72008-08-05 23:31:02 +0000933 // Lookup the entry, lazily creating it if necessary.
John McCallf746aa62010-03-19 23:29:14 +0000934 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
Chris Lattner99b53612009-03-21 08:03:33 +0000935 if (Entry) {
Rafael Espindola6a836702010-03-04 18:17:24 +0000936 if (WeakRefReferences.count(Entry)) {
937 if (D && !D->hasAttr<WeakAttr>())
Anders Carlsson7270ee42010-03-23 04:31:31 +0000938 Entry->setLinkage(llvm::Function::ExternalLinkage);
Rafael Espindola6a836702010-03-04 18:17:24 +0000939
940 WeakRefReferences.erase(Entry);
941 }
942
Chris Lattner74391b42009-03-22 21:03:39 +0000943 if (Entry->getType() == Ty)
Chris Lattner570585c2009-03-21 09:16:30 +0000944 return Entry;
Mike Stump1eb44332009-09-09 15:08:12 +0000945
Chris Lattner99b53612009-03-21 08:03:33 +0000946 // Make sure the result is of the correct type.
Owen Anderson3c4972d2009-07-29 18:54:39 +0000947 return llvm::ConstantExpr::getBitCast(Entry, Ty);
Daniel Dunbar49988882009-01-13 02:25:00 +0000948 }
Mike Stump1eb44332009-09-09 15:08:12 +0000949
Chris Lattner67b00522009-03-21 09:44:56 +0000950 // This is the first use or definition of a mangled name. If there is a
951 // deferred decl with this name, remember that we need to emit it at the end
952 // of the file.
John McCallf746aa62010-03-19 23:29:14 +0000953 llvm::StringMap<GlobalDecl>::iterator DDI = DeferredDecls.find(MangledName);
Chris Lattner67b00522009-03-21 09:44:56 +0000954 if (DDI != DeferredDecls.end()) {
955 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
956 // list, and remove it from DeferredDecls (since we don't need it anymore).
957 DeferredDeclsToEmit.push_back(DDI->second);
958 DeferredDecls.erase(DDI);
959 }
Mike Stump1eb44332009-09-09 15:08:12 +0000960
961 llvm::GlobalVariable *GV =
962 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false,
Chris Lattner99b53612009-03-21 08:03:33 +0000963 llvm::GlobalValue::ExternalLinkage,
John McCallf746aa62010-03-19 23:29:14 +0000964 0, MangledName, 0,
Eli Friedman56ebe502009-04-19 21:05:03 +0000965 false, Ty->getAddressSpace());
Chris Lattner99b53612009-03-21 08:03:33 +0000966
967 // Handle things which are present even on external declarations.
Chris Lattner74391b42009-03-22 21:03:39 +0000968 if (D) {
Mike Stumpf5408fe2009-05-16 07:57:57 +0000969 // FIXME: This code is overly simple and should be merged with other global
970 // handling.
Eli Friedman20e098b2009-12-11 21:23:03 +0000971 GV->setConstant(DeclIsConstantGlobal(Context, D));
Chris Lattner99b53612009-03-21 08:03:33 +0000972
Chris Lattner74391b42009-03-22 21:03:39 +0000973 // FIXME: Merge with other attribute handling code.
974 if (D->getStorageClass() == VarDecl::PrivateExtern)
Daniel Dunbar04d40782009-04-14 06:00:08 +0000975 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
Chris Lattner99b53612009-03-21 08:03:33 +0000976
Mike Stump1eb44332009-09-09 15:08:12 +0000977 if (D->hasAttr<WeakAttr>() ||
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000978 D->hasAttr<WeakImportAttr>())
Chris Lattner74391b42009-03-22 21:03:39 +0000979 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
Eli Friedman56ebe502009-04-19 21:05:03 +0000980
981 GV->setThreadLocal(D->isThreadSpecified());
Chris Lattner74391b42009-03-22 21:03:39 +0000982 }
Mike Stump1eb44332009-09-09 15:08:12 +0000983
John McCallf746aa62010-03-19 23:29:14 +0000984 return GV;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +0000985}
986
Chris Lattner74391b42009-03-22 21:03:39 +0000987
988/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
989/// given global variable. If Ty is non-null and if the global doesn't exist,
990/// then it will be greated with the specified type instead of whatever the
991/// normal requested type would be.
992llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D,
993 const llvm::Type *Ty) {
994 assert(D->hasGlobalStorage() && "Not a global variable");
995 QualType ASTTy = D->getType();
996 if (Ty == 0)
997 Ty = getTypes().ConvertTypeForMem(ASTTy);
Mike Stump1eb44332009-09-09 15:08:12 +0000998
999 const llvm::PointerType *PTy =
Owen Anderson96e0fc72009-07-29 22:16:19 +00001000 llvm::PointerType::get(Ty, ASTTy.getAddressSpace());
John McCallf746aa62010-03-19 23:29:14 +00001001
Anders Carlsson9a20d552010-06-22 16:16:50 +00001002 llvm::StringRef MangledName = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +00001003 return GetOrCreateLLVMGlobal(MangledName, PTy, D);
Chris Lattner74391b42009-03-22 21:03:39 +00001004}
1005
1006/// CreateRuntimeVariable - Create a new runtime global variable with the
1007/// specified type and name.
1008llvm::Constant *
1009CodeGenModule::CreateRuntimeVariable(const llvm::Type *Ty,
John McCallf746aa62010-03-19 23:29:14 +00001010 llvm::StringRef Name) {
Owen Anderson96e0fc72009-07-29 22:16:19 +00001011 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0);
Chris Lattner74391b42009-03-22 21:03:39 +00001012}
1013
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001014void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) {
1015 assert(!D->getInit() && "Cannot emit definite definitions here!");
1016
Douglas Gregor7520bd12009-04-21 19:28:58 +00001017 if (MayDeferGeneration(D)) {
1018 // If we have not seen a reference to this variable yet, place it
1019 // into the deferred declarations table to be emitted if needed
1020 // later.
Anders Carlsson9a20d552010-06-22 16:16:50 +00001021 llvm::StringRef MangledName = getMangledName(D);
John McCallf746aa62010-03-19 23:29:14 +00001022 if (!GetGlobalValue(MangledName)) {
Anders Carlsson555b4bb2009-09-10 23:43:36 +00001023 DeferredDecls[MangledName] = D;
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001024 return;
Douglas Gregor7520bd12009-04-21 19:28:58 +00001025 }
1026 }
1027
1028 // The tentative definition is the only definition.
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001029 EmitGlobalVarDefinition(D);
1030}
1031
Douglas Gregor6fb745b2010-05-13 16:44:06 +00001032void CodeGenModule::EmitVTable(CXXRecordDecl *Class, bool DefinitionRequired) {
1033 if (DefinitionRequired)
1034 getVTables().GenerateClassData(getVTableLinkage(Class), Class);
1035}
1036
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001037llvm::GlobalVariable::LinkageTypes
Anders Carlsson046c2942010-04-17 20:15:18 +00001038CodeGenModule::getVTableLinkage(const CXXRecordDecl *RD) {
Douglas Gregordffb8012010-01-06 22:00:56 +00001039 if (RD->isInAnonymousNamespace() || !RD->hasLinkage())
1040 return llvm::GlobalVariable::InternalLinkage;
1041
1042 if (const CXXMethodDecl *KeyFunction
1043 = RD->getASTContext().getKeyFunction(RD)) {
1044 // If this class has a key function, use that to determine the linkage of
1045 // the vtable.
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001046 const FunctionDecl *Def = 0;
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +00001047 if (KeyFunction->hasBody(Def))
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001048 KeyFunction = cast<CXXMethodDecl>(Def);
Douglas Gregordffb8012010-01-06 22:00:56 +00001049
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001050 switch (KeyFunction->getTemplateSpecializationKind()) {
1051 case TSK_Undeclared:
1052 case TSK_ExplicitSpecialization:
1053 if (KeyFunction->isInlined())
1054 return llvm::GlobalVariable::WeakODRLinkage;
1055
1056 return llvm::GlobalVariable::ExternalLinkage;
1057
1058 case TSK_ImplicitInstantiation:
1059 case TSK_ExplicitInstantiationDefinition:
1060 return llvm::GlobalVariable::WeakODRLinkage;
1061
1062 case TSK_ExplicitInstantiationDeclaration:
1063 // FIXME: Use available_externally linkage. However, this currently
1064 // breaks LLVM's build due to undefined symbols.
1065 // return llvm::GlobalVariable::AvailableExternallyLinkage;
1066 return llvm::GlobalVariable::WeakODRLinkage;
1067 }
Douglas Gregordffb8012010-01-06 22:00:56 +00001068 }
1069
1070 switch (RD->getTemplateSpecializationKind()) {
1071 case TSK_Undeclared:
1072 case TSK_ExplicitSpecialization:
1073 case TSK_ImplicitInstantiation:
1074 case TSK_ExplicitInstantiationDefinition:
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001075 return llvm::GlobalVariable::WeakODRLinkage;
Douglas Gregordffb8012010-01-06 22:00:56 +00001076
1077 case TSK_ExplicitInstantiationDeclaration:
1078 // FIXME: Use available_externally linkage. However, this currently
1079 // breaks LLVM's build due to undefined symbols.
1080 // return llvm::GlobalVariable::AvailableExternallyLinkage;
1081 return llvm::GlobalVariable::WeakODRLinkage;
Douglas Gregor4b0f21c2010-01-06 20:27:16 +00001082 }
1083
1084 // Silence GCC warning.
1085 return llvm::GlobalVariable::WeakODRLinkage;
1086}
1087
Ken Dyck687cc4a2010-01-26 13:48:07 +00001088CharUnits CodeGenModule::GetTargetTypeStoreSize(const llvm::Type *Ty) const {
1089 return CharUnits::fromQuantity(
1090 TheTargetData.getTypeStoreSizeInBits(Ty) / Context.getCharWidth());
1091}
1092
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001093void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
Chris Lattner8f32f712007-07-14 00:23:28 +00001094 llvm::Constant *Init = 0;
Eli Friedman77ba7082008-05-30 19:50:47 +00001095 QualType ASTTy = D->getType();
Eli Friedman6c6bda32010-01-08 00:50:11 +00001096 bool NonConstInit = false;
Mike Stump1eb44332009-09-09 15:08:12 +00001097
Sebastian Redl31310a22010-02-01 20:16:42 +00001098 const Expr *InitExpr = D->getAnyInitializer();
Anders Carlsson3bb92692010-01-26 17:43:42 +00001099
1100 if (!InitExpr) {
Eli Friedmancd5f4aa2008-05-30 20:39:54 +00001101 // This is a tentative definition; tentative definitions are
Daniel Dunbar03f5ad92009-04-15 22:08:45 +00001102 // implicitly initialized with { 0 }.
1103 //
1104 // Note that tentative definitions are only emitted at the end of
1105 // a translation unit, so they should never have incomplete
1106 // type. In addition, EmitTentativeDefinition makes sure that we
1107 // never attempt to emit a tentative definition if a real one
1108 // exists. A use may still exists, however, so we still may need
1109 // to do a RAUW.
1110 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
Anders Carlssonb0d0ea02009-08-02 21:18:22 +00001111 Init = EmitNullConstant(D->getType());
Eli Friedman77ba7082008-05-30 19:50:47 +00001112 } else {
Douglas Gregorc446d182010-05-05 20:15:55 +00001113 Init = EmitConstantExpr(InitExpr, D->getType());
Eli Friedman6e656f42009-02-20 01:18:21 +00001114 if (!Init) {
Anders Carlsson3bb92692010-01-26 17:43:42 +00001115 QualType T = InitExpr->getType();
Douglas Gregorc446d182010-05-05 20:15:55 +00001116 if (D->getType()->isReferenceType())
1117 T = D->getType();
1118
Anders Carlsson89ed31d2009-08-08 23:24:23 +00001119 if (getLangOptions().CPlusPlus) {
Eli Friedman6c6bda32010-01-08 00:50:11 +00001120 EmitCXXGlobalVarDeclInitFunc(D);
Anders Carlsson89ed31d2009-08-08 23:24:23 +00001121 Init = EmitNullConstant(T);
Eli Friedman6c6bda32010-01-08 00:50:11 +00001122 NonConstInit = true;
Anders Carlsson89ed31d2009-08-08 23:24:23 +00001123 } else {
1124 ErrorUnsupported(D, "static initializer");
1125 Init = llvm::UndefValue::get(getTypes().ConvertType(T));
1126 }
John McCallbf40cb52010-07-15 23:40:35 +00001127 } else {
1128 // We don't need an initializer, so remove the entry for the delayed
1129 // initializer position (just in case this entry was delayed).
1130 if (getLangOptions().CPlusPlus)
1131 DelayedCXXInitPosition.erase(D);
Eli Friedman6e656f42009-02-20 01:18:21 +00001132 }
Eli Friedman77ba7082008-05-30 19:50:47 +00001133 }
Eli Friedman77ba7082008-05-30 19:50:47 +00001134
Chris Lattner2d584062009-03-21 08:13:05 +00001135 const llvm::Type* InitType = Init->getType();
Chris Lattner570585c2009-03-21 09:16:30 +00001136 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType);
Mike Stump1eb44332009-09-09 15:08:12 +00001137
Chris Lattner570585c2009-03-21 09:16:30 +00001138 // Strip off a bitcast if we got one back.
1139 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
Chris Lattner9d4a15f2009-07-16 16:48:25 +00001140 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
1141 // all zero index gep.
1142 CE->getOpcode() == llvm::Instruction::GetElementPtr);
Chris Lattner570585c2009-03-21 09:16:30 +00001143 Entry = CE->getOperand(0);
1144 }
Mike Stump1eb44332009-09-09 15:08:12 +00001145
Chris Lattner570585c2009-03-21 09:16:30 +00001146 // Entry is now either a Function or GlobalVariable.
1147 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00001148
Chris Lattner570585c2009-03-21 09:16:30 +00001149 // We have a definition after a declaration with the wrong type.
1150 // We must make a new GlobalVariable* and update everything that used OldGV
1151 // (a declaration or tentative definition) with the new GlobalVariable*
1152 // (which will be a definition).
1153 //
1154 // This happens if there is a prototype for a global (e.g.
1155 // "extern int x[];") and then a definition of a different type (e.g.
1156 // "int x[10];"). This also happens when an initializer has a different type
1157 // from the type of the global (this happens with unions).
Chris Lattner570585c2009-03-21 09:16:30 +00001158 if (GV == 0 ||
1159 GV->getType()->getElementType() != InitType ||
1160 GV->getType()->getAddressSpace() != ASTTy.getAddressSpace()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001161
John McCallf746aa62010-03-19 23:29:14 +00001162 // Move the old entry aside so that we'll create a new one.
1163 Entry->setName(llvm::StringRef());
Daniel Dunbar232350d2009-02-19 05:36:41 +00001164
Chris Lattner570585c2009-03-21 09:16:30 +00001165 // Make a new global with the correct type, this is now guaranteed to work.
1166 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType));
Chris Lattner0558e792009-03-21 09:25:43 +00001167
Eli Friedman77ba7082008-05-30 19:50:47 +00001168 // Replace all uses of the old global with the new global
Mike Stump1eb44332009-09-09 15:08:12 +00001169 llvm::Constant *NewPtrForOldDecl =
Owen Anderson3c4972d2009-07-29 18:54:39 +00001170 llvm::ConstantExpr::getBitCast(GV, Entry->getType());
Chris Lattner570585c2009-03-21 09:16:30 +00001171 Entry->replaceAllUsesWith(NewPtrForOldDecl);
Eli Friedman77ba7082008-05-30 19:50:47 +00001172
1173 // Erase the old global, since it is no longer used.
Chris Lattner570585c2009-03-21 09:16:30 +00001174 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
Chris Lattner8f32f712007-07-14 00:23:28 +00001175 }
Devang Patel8e53e722007-10-26 16:31:40 +00001176
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001177 if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) {
Nate Begeman8bd4afe2008-04-19 04:17:09 +00001178 SourceManager &SM = Context.getSourceManager();
1179 AddAnnotation(EmitAnnotateAttr(GV, AA,
Chris Lattnerf7cf85b2009-01-16 07:36:28 +00001180 SM.getInstantiationLineNumber(D->getLocation())));
Nate Begeman8bd4afe2008-04-19 04:17:09 +00001181 }
1182
Chris Lattner88a69ad2007-07-13 05:13:43 +00001183 GV->setInitializer(Init);
Chris Lattnere78b86f2009-08-05 05:20:29 +00001184
1185 // If it is safe to mark the global 'constant', do so now.
1186 GV->setConstant(false);
Eli Friedman6c6bda32010-01-08 00:50:11 +00001187 if (!NonConstInit && DeclIsConstantGlobal(Context, D))
Chris Lattnere78b86f2009-08-05 05:20:29 +00001188 GV->setConstant(true);
Mike Stump1eb44332009-09-09 15:08:12 +00001189
Ken Dyck8b752f12010-01-27 17:10:57 +00001190 GV->setAlignment(getContext().getDeclAlign(D).getQuantity());
Eli Friedman08d78022008-05-29 11:10:27 +00001191
Chris Lattner88a69ad2007-07-13 05:13:43 +00001192 // Set the llvm linkage type as appropriate.
Argyrios Kyrtzidis90e99a82010-07-29 18:15:58 +00001193 GVALinkage Linkage = getContext().GetGVALinkageForVariable(D);
Douglas Gregora0f00a72009-10-14 21:36:34 +00001194 if (Linkage == GVA_Internal)
Chris Lattner8fabd782008-05-04 01:44:26 +00001195 GV->setLinkage(llvm::Function::InternalLinkage);
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001196 else if (D->hasAttr<DLLImportAttr>())
Chris Lattnerddee4232008-03-03 03:28:21 +00001197 GV->setLinkage(llvm::Function::DLLImportLinkage);
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001198 else if (D->hasAttr<DLLExportAttr>())
Chris Lattnerddee4232008-03-03 03:28:21 +00001199 GV->setLinkage(llvm::Function::DLLExportLinkage);
Chris Lattnere78b86f2009-08-05 05:20:29 +00001200 else if (D->hasAttr<WeakAttr>()) {
1201 if (GV->isConstant())
1202 GV->setLinkage(llvm::GlobalVariable::WeakODRLinkage);
1203 else
1204 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
Douglas Gregor8f51a4f2010-03-13 18:23:07 +00001205 } else if (Linkage == GVA_TemplateInstantiation ||
1206 Linkage == GVA_ExplicitTemplateInstantiation)
1207 // FIXME: It seems like we can provide more specific linkage here
1208 // (LinkOnceODR, WeakODR).
Douglas Gregor1028c9f2009-10-14 21:29:40 +00001209 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
Daniel Dunbar1bc5c032009-11-30 08:40:34 +00001210 else if (!getLangOptions().CPlusPlus && !CodeGenOpts.NoCommon &&
Chris Lattner309457d2009-08-05 04:56:58 +00001211 !D->hasExternalStorage() && !D->getInit() &&
Eric Christopher91f31dc2010-08-08 01:37:14 +00001212 !D->getAttr<SectionAttr>() && !D->isThreadSpecified()) {
1213 // Thread local vars aren't considered common linkage.
Daniel Dunbar04d40782009-04-14 06:00:08 +00001214 GV->setLinkage(llvm::GlobalVariable::CommonLinkage);
Chris Lattnere78b86f2009-08-05 05:20:29 +00001215 // common vars aren't constant even if declared const.
1216 GV->setConstant(false);
1217 } else
Daniel Dunbar04d40782009-04-14 06:00:08 +00001218 GV->setLinkage(llvm::GlobalVariable::ExternalLinkage);
Daniel Dunbar7e714cd2009-04-10 20:26:50 +00001219
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001220 SetCommonAttributes(D, GV);
Daniel Dunbar04d40782009-04-14 06:00:08 +00001221
Sanjiv Gupta686226b2008-06-05 08:59:10 +00001222 // Emit global variable debug information.
Chris Lattner2d584062009-03-21 08:13:05 +00001223 if (CGDebugInfo *DI = getDebugInfo()) {
Daniel Dunbar66031a52008-10-17 16:15:48 +00001224 DI->setLocation(D->getLocation());
Sanjiv Gupta686226b2008-06-05 08:59:10 +00001225 DI->EmitGlobalVariable(GV, D);
1226 }
Chris Lattner88a69ad2007-07-13 05:13:43 +00001227}
Reid Spencer5f016e22007-07-11 17:01:13 +00001228
Chris Lattnerbdb01322009-05-05 06:16:31 +00001229/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
1230/// implement a function with no prototype, e.g. "int foo() {}". If there are
1231/// existing call uses of the old function in the module, this adjusts them to
1232/// call the new function directly.
1233///
1234/// This is not just a cleanup: the always_inline pass requires direct calls to
1235/// functions to be able to inline them. If there is a bitcast in the way, it
1236/// won't inline them. Instcombine normally deletes these calls, but it isn't
1237/// run at -O0.
1238static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
1239 llvm::Function *NewFn) {
1240 // If we're redefining a global as a function, don't transform it.
1241 llvm::Function *OldFn = dyn_cast<llvm::Function>(Old);
1242 if (OldFn == 0) return;
Mike Stump1eb44332009-09-09 15:08:12 +00001243
Chris Lattnerbdb01322009-05-05 06:16:31 +00001244 const llvm::Type *NewRetTy = NewFn->getReturnType();
1245 llvm::SmallVector<llvm::Value*, 4> ArgList;
1246
1247 for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end();
Benjamin Kramerdbf02bc2010-04-10 11:02:40 +00001248 UI != E; ) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00001249 // TODO: Do invokes ever occur in C code? If so, we should handle them too.
Benjamin Kramerdbf02bc2010-04-10 11:02:40 +00001250 llvm::Value::use_iterator I = UI++; // Increment before the CI is erased.
1251 llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*I);
Gabor Greif8670cd32010-07-28 09:19:33 +00001252 if (!CI) continue; // FIXME: when we allow Invoke, just do CallSite CS(*I)
Gabor Greif35db3b92010-04-10 03:45:50 +00001253 llvm::CallSite CS(CI);
Benjamin Kramerdbf02bc2010-04-10 11:02:40 +00001254 if (!CI || !CS.isCallee(I)) continue;
Mike Stump1eb44332009-09-09 15:08:12 +00001255
Chris Lattnerbdb01322009-05-05 06:16:31 +00001256 // If the return types don't match exactly, and if the call isn't dead, then
1257 // we can't transform this call.
1258 if (CI->getType() != NewRetTy && !CI->use_empty())
1259 continue;
1260
1261 // If the function was passed too few arguments, don't transform. If extra
1262 // arguments were passed, we silently drop them. If any of the types
1263 // mismatch, we don't transform.
1264 unsigned ArgNo = 0;
1265 bool DontTransform = false;
1266 for (llvm::Function::arg_iterator AI = NewFn->arg_begin(),
1267 E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) {
Gabor Greif35db3b92010-04-10 03:45:50 +00001268 if (CS.arg_size() == ArgNo ||
1269 CS.getArgument(ArgNo)->getType() != AI->getType()) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00001270 DontTransform = true;
1271 break;
1272 }
1273 }
1274 if (DontTransform)
1275 continue;
Mike Stump1eb44332009-09-09 15:08:12 +00001276
Chris Lattnerbdb01322009-05-05 06:16:31 +00001277 // Okay, we can transform this. Create the new call instruction and copy
1278 // over the required information.
Gabor Greif6ba728d2010-04-10 02:56:12 +00001279 ArgList.append(CS.arg_begin(), CS.arg_begin() + ArgNo);
Chris Lattnerbdb01322009-05-05 06:16:31 +00001280 llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList.begin(),
1281 ArgList.end(), "", CI);
1282 ArgList.clear();
Benjamin Kramerffbb15e2009-10-05 13:47:21 +00001283 if (!NewCall->getType()->isVoidTy())
Chris Lattnerbdb01322009-05-05 06:16:31 +00001284 NewCall->takeName(CI);
Chris Lattnerbdb01322009-05-05 06:16:31 +00001285 NewCall->setAttributes(CI->getAttributes());
Daniel Dunbarca6408c2009-09-12 00:59:20 +00001286 NewCall->setCallingConv(CI->getCallingConv());
Chris Lattnerbdb01322009-05-05 06:16:31 +00001287
1288 // Finally, remove the old call, replacing any uses with the new one.
Chris Lattner00549fc2009-10-14 05:49:21 +00001289 if (!CI->use_empty())
1290 CI->replaceAllUsesWith(NewCall);
Devang Patel3b122bc2009-10-13 17:02:04 +00001291
Chris Lattnerc6034632010-04-01 06:31:43 +00001292 // Copy debug location attached to CI.
1293 if (!CI->getDebugLoc().isUnknown())
1294 NewCall->setDebugLoc(CI->getDebugLoc());
Chris Lattnerbdb01322009-05-05 06:16:31 +00001295 CI->eraseFromParent();
1296 }
1297}
1298
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001299
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001300void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) {
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001301 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl());
John McCallc0bf4622010-02-23 00:48:20 +00001302 const llvm::FunctionType *Ty = getTypes().GetFunctionType(GD);
Fariborz Jahanian4819ac42010-03-04 01:02:03 +00001303 getMangleContext().mangleInitDiscriminator();
Chris Lattner9fa959d2009-05-12 20:58:15 +00001304 // Get or create the prototype for the function.
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001305 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty);
Mike Stump1eb44332009-09-09 15:08:12 +00001306
Chris Lattner0558e792009-03-21 09:25:43 +00001307 // Strip off a bitcast if we got one back.
1308 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) {
1309 assert(CE->getOpcode() == llvm::Instruction::BitCast);
1310 Entry = CE->getOperand(0);
1311 }
Mike Stump1eb44332009-09-09 15:08:12 +00001312
1313
Chris Lattner0558e792009-03-21 09:25:43 +00001314 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00001315 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00001316
Daniel Dunbar42745812009-03-09 23:53:08 +00001317 // If the types mismatch then we have to rewrite the definition.
Chris Lattnerbdb01322009-05-05 06:16:31 +00001318 assert(OldFn->isDeclaration() &&
Chris Lattner0558e792009-03-21 09:25:43 +00001319 "Shouldn't replace non-declaration");
Chris Lattner34809502009-03-21 08:53:37 +00001320
Chris Lattner62b33ea2009-03-21 08:38:50 +00001321 // F is the Function* for the one with the wrong type, we must make a new
1322 // Function* and update everything that used F (a declaration) with the new
1323 // Function* (which will be a definition).
1324 //
1325 // This happens if there is a prototype for a function
1326 // (e.g. "int f()") and then a definition of a different type
John McCallf746aa62010-03-19 23:29:14 +00001327 // (e.g. "int f(int x)"). Move the old function aside so that it
1328 // doesn't interfere with GetAddrOfFunction.
1329 OldFn->setName(llvm::StringRef());
Chris Lattnerb4880ba2009-05-12 21:21:08 +00001330 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty));
Mike Stump1eb44332009-09-09 15:08:12 +00001331
Chris Lattnerbdb01322009-05-05 06:16:31 +00001332 // If this is an implementation of a function without a prototype, try to
1333 // replace any existing uses of the function (which may be calls) with uses
1334 // of the new function
Chris Lattner9fa959d2009-05-12 20:58:15 +00001335 if (D->getType()->isFunctionNoProtoType()) {
Chris Lattnerbdb01322009-05-05 06:16:31 +00001336 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn);
Chris Lattner9fa959d2009-05-12 20:58:15 +00001337 OldFn->removeDeadConstantUsers();
1338 }
Mike Stump1eb44332009-09-09 15:08:12 +00001339
Chris Lattner62b33ea2009-03-21 08:38:50 +00001340 // Replace uses of F with the Function we will endow with a body.
Chris Lattnerbdb01322009-05-05 06:16:31 +00001341 if (!Entry->use_empty()) {
Mike Stump1eb44332009-09-09 15:08:12 +00001342 llvm::Constant *NewPtrForOldDecl =
Owen Anderson3c4972d2009-07-29 18:54:39 +00001343 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType());
Chris Lattnerbdb01322009-05-05 06:16:31 +00001344 Entry->replaceAllUsesWith(NewPtrForOldDecl);
1345 }
Mike Stump1eb44332009-09-09 15:08:12 +00001346
Chris Lattner62b33ea2009-03-21 08:38:50 +00001347 // Ok, delete the old function now, which is dead.
Chris Lattnerbdb01322009-05-05 06:16:31 +00001348 OldFn->eraseFromParent();
Mike Stump1eb44332009-09-09 15:08:12 +00001349
Chris Lattner0558e792009-03-21 09:25:43 +00001350 Entry = NewFn;
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001351 }
Mike Stump1eb44332009-09-09 15:08:12 +00001352
Chris Lattner0558e792009-03-21 09:25:43 +00001353 llvm::Function *Fn = cast<llvm::Function>(Entry);
John McCall8b242332010-05-25 04:30:21 +00001354 setFunctionLinkage(D, Fn);
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001355
Daniel Dunbar219df662008-09-08 23:44:31 +00001356 CodeGenFunction(*this).GenerateCode(D, Fn);
Daniel Dunbar6bfed7e2008-08-01 00:01:51 +00001357
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001358 SetFunctionDefinitionAttributes(D, Fn);
1359 SetLLVMFunctionAttributesForDefinition(D, Fn);
Mike Stump1eb44332009-09-09 15:08:12 +00001360
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001361 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
Daniel Dunbar219df662008-09-08 23:44:31 +00001362 AddGlobalCtor(Fn, CA->getPriority());
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001363 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
Daniel Dunbar219df662008-09-08 23:44:31 +00001364 AddGlobalDtor(Fn, DA->getPriority());
Daniel Dunbarbd012ff2008-07-29 23:18:29 +00001365}
1366
John McCallf746aa62010-03-19 23:29:14 +00001367void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
1368 const ValueDecl *D = cast<ValueDecl>(GD.getDecl());
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001369 const AliasAttr *AA = D->getAttr<AliasAttr>();
Chris Lattnerbd532712009-03-22 21:47:11 +00001370 assert(AA && "Not an alias?");
1371
Anders Carlsson9a20d552010-06-22 16:16:50 +00001372 llvm::StringRef MangledName = getMangledName(GD);
Mike Stump1eb44332009-09-09 15:08:12 +00001373
John McCallf746aa62010-03-19 23:29:14 +00001374 // If there is a definition in the module, then it wins over the alias.
1375 // This is dubious, but allow it to be safe. Just ignore the alias.
1376 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1377 if (Entry && !Entry->isDeclaration())
1378 return;
1379
1380 const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
Chris Lattnerbd532712009-03-22 21:47:11 +00001381
1382 // Create a reference to the named value. This ensures that it is emitted
1383 // if a deferred decl.
1384 llvm::Constant *Aliasee;
1385 if (isa<llvm::FunctionType>(DeclTy))
John McCallf746aa62010-03-19 23:29:14 +00001386 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GlobalDecl());
Chris Lattnerbd532712009-03-22 21:47:11 +00001387 else
John McCallf746aa62010-03-19 23:29:14 +00001388 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(),
Owen Anderson96e0fc72009-07-29 22:16:19 +00001389 llvm::PointerType::getUnqual(DeclTy), 0);
Chris Lattnerbd532712009-03-22 21:47:11 +00001390
1391 // Create the new alias itself, but don't set a name yet.
Mike Stump1eb44332009-09-09 15:08:12 +00001392 llvm::GlobalValue *GA =
Chris Lattnerbd532712009-03-22 21:47:11 +00001393 new llvm::GlobalAlias(Aliasee->getType(),
1394 llvm::Function::ExternalLinkage,
1395 "", Aliasee, &getModule());
Mike Stump1eb44332009-09-09 15:08:12 +00001396
Chris Lattnerbd532712009-03-22 21:47:11 +00001397 if (Entry) {
John McCallf746aa62010-03-19 23:29:14 +00001398 assert(Entry->isDeclaration());
1399
Chris Lattnerbd532712009-03-22 21:47:11 +00001400 // If there is a declaration in the module, then we had an extern followed
1401 // by the alias, as in:
1402 // extern int test6();
1403 // ...
1404 // int test6() __attribute__((alias("test7")));
1405 //
1406 // Remove it and replace uses of it with the alias.
John McCallf746aa62010-03-19 23:29:14 +00001407 GA->takeName(Entry);
Mike Stump1eb44332009-09-09 15:08:12 +00001408
Owen Anderson3c4972d2009-07-29 18:54:39 +00001409 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA,
Chris Lattnerbd532712009-03-22 21:47:11 +00001410 Entry->getType()));
Chris Lattnerbd532712009-03-22 21:47:11 +00001411 Entry->eraseFromParent();
John McCallf746aa62010-03-19 23:29:14 +00001412 } else {
Anders Carlsson9a20d552010-06-22 16:16:50 +00001413 GA->setName(MangledName);
Chris Lattnerbd532712009-03-22 21:47:11 +00001414 }
Mike Stump1eb44332009-09-09 15:08:12 +00001415
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001416 // Set attributes which are particular to an alias; this is a
1417 // specialization of the attributes which may be set on a global
1418 // variable/function.
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001419 if (D->hasAttr<DLLExportAttr>()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001420 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1421 // The dllexport attribute is ignored for undefined symbols.
Argyrios Kyrtzidis06a54a32010-07-07 11:31:19 +00001422 if (FD->hasBody())
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001423 GA->setLinkage(llvm::Function::DLLExportLinkage);
1424 } else {
1425 GA->setLinkage(llvm::Function::DLLExportLinkage);
1426 }
Mike Stump1eb44332009-09-09 15:08:12 +00001427 } else if (D->hasAttr<WeakAttr>() ||
Rafael Espindola11e8ce72010-02-23 22:00:30 +00001428 D->hasAttr<WeakRefAttr>() ||
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +00001429 D->hasAttr<WeakImportAttr>()) {
Daniel Dunbar7c65e992009-04-14 08:05:55 +00001430 GA->setLinkage(llvm::Function::WeakAnyLinkage);
1431 }
1432
1433 SetCommonAttributes(D, GA);
Chris Lattnerbd532712009-03-22 21:47:11 +00001434}
1435
Chris Lattnerb808c952009-03-22 21:56:56 +00001436/// getBuiltinLibFunction - Given a builtin id for a function like
1437/// "__builtin_fabsf", return a Function* for "fabsf".
Daniel Dunbar34771b52009-09-14 04:33:21 +00001438llvm::Value *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD,
1439 unsigned BuiltinID) {
Douglas Gregor3e41d602009-02-13 23:20:09 +00001440 assert((Context.BuiltinInfo.isLibFunction(BuiltinID) ||
Mike Stump1eb44332009-09-09 15:08:12 +00001441 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) &&
Douglas Gregor3e41d602009-02-13 23:20:09 +00001442 "isn't a lib fn");
Mike Stump1eb44332009-09-09 15:08:12 +00001443
Douglas Gregor3e41d602009-02-13 23:20:09 +00001444 // Get the name, skip over the __builtin_ prefix (if necessary).
1445 const char *Name = Context.BuiltinInfo.GetName(BuiltinID);
1446 if (Context.BuiltinInfo.isLibFunction(BuiltinID))
1447 Name += 10;
Mike Stump1eb44332009-09-09 15:08:12 +00001448
Mike Stump1eb44332009-09-09 15:08:12 +00001449 const llvm::FunctionType *Ty =
Eli Friedman386ca782009-12-09 03:05:59 +00001450 cast<llvm::FunctionType>(getTypes().ConvertType(FD->getType()));
Chris Lattnerbef20ac2007-08-31 04:31:45 +00001451
Daniel Dunbar34771b52009-09-14 04:33:21 +00001452 return GetOrCreateLLVMFunction(Name, Ty, GlobalDecl(FD));
Chris Lattnerbef20ac2007-08-31 04:31:45 +00001453}
1454
Chris Lattner7acda7c2007-12-18 00:25:38 +00001455llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys,
1456 unsigned NumTys) {
1457 return llvm::Intrinsic::getDeclaration(&getModule(),
1458 (llvm::Intrinsic::ID)IID, Tys, NumTys);
1459}
Chris Lattnerbef20ac2007-08-31 04:31:45 +00001460
Mon P Wang3ecd7852010-04-04 03:10:52 +00001461
1462llvm::Function *CodeGenModule::getMemCpyFn(const llvm::Type *DestType,
1463 const llvm::Type *SrcType,
1464 const llvm::Type *SizeType) {
1465 const llvm::Type *ArgTypes[3] = {DestType, SrcType, SizeType };
1466 return getIntrinsic(llvm::Intrinsic::memcpy, ArgTypes, 3);
Reid Spencer5f016e22007-07-11 17:01:13 +00001467}
Anders Carlssonc9e20912007-08-21 00:21:21 +00001468
Mon P Wang3ecd7852010-04-04 03:10:52 +00001469llvm::Function *CodeGenModule::getMemMoveFn(const llvm::Type *DestType,
1470 const llvm::Type *SrcType,
1471 const llvm::Type *SizeType) {
1472 const llvm::Type *ArgTypes[3] = {DestType, SrcType, SizeType };
1473 return getIntrinsic(llvm::Intrinsic::memmove, ArgTypes, 3);
Eli Friedman0c995092008-05-26 12:59:39 +00001474}
1475
Mon P Wang3ecd7852010-04-04 03:10:52 +00001476llvm::Function *CodeGenModule::getMemSetFn(const llvm::Type *DestType,
1477 const llvm::Type *SizeType) {
1478 const llvm::Type *ArgTypes[2] = { DestType, SizeType };
1479 return getIntrinsic(llvm::Intrinsic::memset, ArgTypes, 2);
Lauro Ramos Venancio41ef30e2008-02-19 22:01:01 +00001480}
Chris Lattner7acda7c2007-12-18 00:25:38 +00001481
Daniel Dunbar1d552912009-07-23 22:52:48 +00001482static llvm::StringMapEntry<llvm::Constant*> &
1483GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map,
1484 const StringLiteral *Literal,
Daniel Dunbar70ee9752009-07-23 23:41:22 +00001485 bool TargetIsLSB,
Daniel Dunbar1d552912009-07-23 22:52:48 +00001486 bool &IsUTF16,
1487 unsigned &StringLength) {
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00001488 llvm::StringRef String = Literal->getString();
1489 unsigned NumBytes = String.size();
Daniel Dunbar1d552912009-07-23 22:52:48 +00001490
Daniel Dunbarf015b032009-09-22 10:03:52 +00001491 // Check for simple case.
1492 if (!Literal->containsNonAsciiOrNull()) {
1493 StringLength = NumBytes;
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00001494 return Map.GetOrCreateValue(String);
Daniel Dunbarf015b032009-09-22 10:03:52 +00001495 }
1496
Daniel Dunbar1d552912009-07-23 22:52:48 +00001497 // Otherwise, convert the UTF8 literals into a byte string.
1498 llvm::SmallVector<UTF16, 128> ToBuf(NumBytes);
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00001499 const UTF8 *FromPtr = (UTF8 *)String.data();
Daniel Dunbar1d552912009-07-23 22:52:48 +00001500 UTF16 *ToPtr = &ToBuf[0];
Mike Stump1eb44332009-09-09 15:08:12 +00001501
1502 ConversionResult Result = ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes,
Daniel Dunbar1d552912009-07-23 22:52:48 +00001503 &ToPtr, ToPtr + NumBytes,
1504 strictConversion);
Mike Stump1eb44332009-09-09 15:08:12 +00001505
Daniel Dunbar1d552912009-07-23 22:52:48 +00001506 // Check for conversion failure.
1507 if (Result != conversionOK) {
1508 // FIXME: Have Sema::CheckObjCString() validate the UTF-8 string and remove
1509 // this duplicate code.
1510 assert(Result == sourceIllegal && "UTF-8 to UTF-16 conversion failed");
Daniel Dunbarf015b032009-09-22 10:03:52 +00001511 StringLength = NumBytes;
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00001512 return Map.GetOrCreateValue(String);
Daniel Dunbar1d552912009-07-23 22:52:48 +00001513 }
1514
Daniel Dunbar70ee9752009-07-23 23:41:22 +00001515 // ConvertUTF8toUTF16 returns the length in ToPtr.
Daniel Dunbar1d552912009-07-23 22:52:48 +00001516 StringLength = ToPtr - &ToBuf[0];
Daniel Dunbar70ee9752009-07-23 23:41:22 +00001517
1518 // Render the UTF-16 string into a byte array and convert to the target byte
1519 // order.
1520 //
1521 // FIXME: This isn't something we should need to do here.
1522 llvm::SmallString<128> AsBytes;
1523 AsBytes.reserve(StringLength * 2);
1524 for (unsigned i = 0; i != StringLength; ++i) {
1525 unsigned short Val = ToBuf[i];
1526 if (TargetIsLSB) {
1527 AsBytes.push_back(Val & 0xFF);
1528 AsBytes.push_back(Val >> 8);
1529 } else {
1530 AsBytes.push_back(Val >> 8);
1531 AsBytes.push_back(Val & 0xFF);
1532 }
1533 }
Daniel Dunbar434da482009-08-03 21:47:08 +00001534 // Append one extra null character, the second is automatically added by our
1535 // caller.
1536 AsBytes.push_back(0);
Daniel Dunbar70ee9752009-07-23 23:41:22 +00001537
Daniel Dunbar1d552912009-07-23 22:52:48 +00001538 IsUTF16 = true;
Daniel Dunbar70ee9752009-07-23 23:41:22 +00001539 return Map.GetOrCreateValue(llvm::StringRef(AsBytes.data(), AsBytes.size()));
Daniel Dunbar1d552912009-07-23 22:52:48 +00001540}
1541
1542llvm::Constant *
1543CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
1544 unsigned StringLength = 0;
1545 bool isUTF16 = false;
1546 llvm::StringMapEntry<llvm::Constant*> &Entry =
Mike Stump1eb44332009-09-09 15:08:12 +00001547 GetConstantCFStringEntry(CFConstantStringMap, Literal,
Daniel Dunbar70ee9752009-07-23 23:41:22 +00001548 getTargetData().isLittleEndian(),
1549 isUTF16, StringLength);
Mike Stump1eb44332009-09-09 15:08:12 +00001550
Daniel Dunbar1d552912009-07-23 22:52:48 +00001551 if (llvm::Constant *C = Entry.getValue())
1552 return C;
Mike Stump1eb44332009-09-09 15:08:12 +00001553
Owen Anderson0032b272009-08-13 21:57:51 +00001554 llvm::Constant *Zero =
1555 llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext));
Daniel Dunbar3e9df992008-08-23 18:37:06 +00001556 llvm::Constant *Zeros[] = { Zero, Zero };
Mike Stump1eb44332009-09-09 15:08:12 +00001557
Chris Lattner9d4a15f2009-07-16 16:48:25 +00001558 // If we don't already have it, get __CFConstantStringClassReference.
Anders Carlssonc9e20912007-08-21 00:21:21 +00001559 if (!CFConstantStringClassRef) {
1560 const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
Owen Anderson96e0fc72009-07-29 22:16:19 +00001561 Ty = llvm::ArrayType::get(Ty, 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001562 llvm::Constant *GV = CreateRuntimeVariable(Ty,
Chris Lattner9d4a15f2009-07-16 16:48:25 +00001563 "__CFConstantStringClassReference");
Daniel Dunbar3e9df992008-08-23 18:37:06 +00001564 // Decay array -> ptr
1565 CFConstantStringClassRef =
Owen Anderson3c4972d2009-07-29 18:54:39 +00001566 llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
Anders Carlssonc9e20912007-08-21 00:21:21 +00001567 }
Mike Stump1eb44332009-09-09 15:08:12 +00001568
Anders Carlssone3daa762008-11-15 18:54:24 +00001569 QualType CFTy = getContext().getCFConstantStringType();
Daniel Dunbar3e9df992008-08-23 18:37:06 +00001570
Mike Stump1eb44332009-09-09 15:08:12 +00001571 const llvm::StructType *STy =
Anders Carlssone3daa762008-11-15 18:54:24 +00001572 cast<llvm::StructType>(getTypes().ConvertType(CFTy));
1573
Anders Carlsson5add6832009-08-16 05:55:31 +00001574 std::vector<llvm::Constant*> Fields(4);
Douglas Gregor44b43212008-12-11 16:49:14 +00001575
Anders Carlssonc9e20912007-08-21 00:21:21 +00001576 // Class pointer.
Anders Carlsson5add6832009-08-16 05:55:31 +00001577 Fields[0] = CFConstantStringClassRef;
Mike Stump1eb44332009-09-09 15:08:12 +00001578
Anders Carlssonc9e20912007-08-21 00:21:21 +00001579 // Flags.
Daniel Dunbar3e9df992008-08-23 18:37:06 +00001580 const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
Mike Stump1eb44332009-09-09 15:08:12 +00001581 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) :
Anders Carlsson5add6832009-08-16 05:55:31 +00001582 llvm::ConstantInt::get(Ty, 0x07C8);
1583
Anders Carlssonc9e20912007-08-21 00:21:21 +00001584 // String pointer.
Owen Anderson0032b272009-08-13 21:57:51 +00001585 llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str());
Daniel Dunbara9668e02009-04-03 00:57:44 +00001586
Chris Lattner95b851e2009-07-16 05:03:48 +00001587 llvm::GlobalValue::LinkageTypes Linkage;
Chris Lattner278b9f02009-10-14 05:55:45 +00001588 bool isConstant;
Daniel Dunbara9668e02009-04-03 00:57:44 +00001589 if (isUTF16) {
Chris Lattner278b9f02009-10-14 05:55:45 +00001590 // FIXME: why do utf strings get "_" labels instead of "L" labels?
Chris Lattner95b851e2009-07-16 05:03:48 +00001591 Linkage = llvm::GlobalValue::InternalLinkage;
Chris Lattner278b9f02009-10-14 05:55:45 +00001592 // Note: -fwritable-strings doesn't make unicode CFStrings writable, but
1593 // does make plain ascii ones writable.
Daniel Dunbara9668e02009-04-03 00:57:44 +00001594 isConstant = true;
Chris Lattner278b9f02009-10-14 05:55:45 +00001595 } else {
1596 Linkage = llvm::GlobalValue::PrivateLinkage;
1597 isConstant = !Features.WritableStrings;
Daniel Dunbara9668e02009-04-03 00:57:44 +00001598 }
Chris Lattner278b9f02009-10-14 05:55:45 +00001599
Mike Stump1eb44332009-09-09 15:08:12 +00001600 llvm::GlobalVariable *GV =
Chris Lattner278b9f02009-10-14 05:55:45 +00001601 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
1602 ".str");
Daniel Dunbara9668e02009-04-03 00:57:44 +00001603 if (isUTF16) {
Ken Dyck4da244c2010-01-26 18:46:23 +00001604 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
1605 GV->setAlignment(Align.getQuantity());
Daniel Dunbara9668e02009-04-03 00:57:44 +00001606 }
Anders Carlsson5add6832009-08-16 05:55:31 +00001607 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
1608
Anders Carlssonc9e20912007-08-21 00:21:21 +00001609 // String length.
1610 Ty = getTypes().ConvertType(getContext().LongTy);
Anders Carlsson5add6832009-08-16 05:55:31 +00001611 Fields[3] = llvm::ConstantInt::get(Ty, StringLength);
Mike Stump1eb44332009-09-09 15:08:12 +00001612
Anders Carlssonc9e20912007-08-21 00:21:21 +00001613 // The struct.
Owen Anderson08e25242009-07-27 22:29:56 +00001614 C = llvm::ConstantStruct::get(STy, Fields);
Mike Stump1eb44332009-09-09 15:08:12 +00001615 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
1616 llvm::GlobalVariable::PrivateLinkage, C,
Chris Lattner95b851e2009-07-16 05:03:48 +00001617 "_unnamed_cfstring_");
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00001618 if (const char *Sect = getContext().Target.getCFStringSection())
1619 GV->setSection(Sect);
Daniel Dunbar1d552912009-07-23 22:52:48 +00001620 Entry.setValue(GV);
Mike Stump1eb44332009-09-09 15:08:12 +00001621
Anders Carlsson0c678292007-11-01 00:41:52 +00001622 return GV;
Anders Carlssonc9e20912007-08-21 00:21:21 +00001623}
Chris Lattner45e8cbd2007-11-28 05:34:05 +00001624
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00001625llvm::Constant *
1626CodeGenModule::GetAddrOfConstantNSString(const StringLiteral *Literal) {
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001627 unsigned StringLength = 0;
1628 bool isUTF16 = false;
1629 llvm::StringMapEntry<llvm::Constant*> &Entry =
1630 GetConstantCFStringEntry(CFConstantStringMap, Literal,
1631 getTargetData().isLittleEndian(),
1632 isUTF16, StringLength);
1633
1634 if (llvm::Constant *C = Entry.getValue())
1635 return C;
1636
1637 llvm::Constant *Zero =
1638 llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext));
1639 llvm::Constant *Zeros[] = { Zero, Zero };
1640
Fariborz Jahanianec951e02010-04-23 22:33:39 +00001641 // If we don't already have it, get _NSConstantStringClassReference.
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001642 if (!NSConstantStringClassRef) {
1643 const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
1644 Ty = llvm::ArrayType::get(Ty, 0);
Fariborz Jahanianec951e02010-04-23 22:33:39 +00001645 llvm::Constant *GV = CreateRuntimeVariable(Ty,
1646 Features.ObjCNonFragileABI ?
1647 "OBJC_CLASS_$_NSConstantString" :
1648 "_NSConstantStringClassReference");
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001649 // Decay array -> ptr
1650 NSConstantStringClassRef =
1651 llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
1652 }
1653
1654 QualType NSTy = getContext().getNSConstantStringType();
1655
1656 const llvm::StructType *STy =
1657 cast<llvm::StructType>(getTypes().ConvertType(NSTy));
1658
1659 std::vector<llvm::Constant*> Fields(3);
1660
1661 // Class pointer.
1662 Fields[0] = NSConstantStringClassRef;
1663
1664 // String pointer.
1665 llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str());
1666
1667 llvm::GlobalValue::LinkageTypes Linkage;
1668 bool isConstant;
1669 if (isUTF16) {
1670 // FIXME: why do utf strings get "_" labels instead of "L" labels?
1671 Linkage = llvm::GlobalValue::InternalLinkage;
1672 // Note: -fwritable-strings doesn't make unicode NSStrings writable, but
1673 // does make plain ascii ones writable.
1674 isConstant = true;
1675 } else {
1676 Linkage = llvm::GlobalValue::PrivateLinkage;
1677 isConstant = !Features.WritableStrings;
1678 }
1679
1680 llvm::GlobalVariable *GV =
1681 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, Linkage, C,
1682 ".str");
1683 if (isUTF16) {
1684 CharUnits Align = getContext().getTypeAlignInChars(getContext().ShortTy);
1685 GV->setAlignment(Align.getQuantity());
1686 }
1687 Fields[1] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2);
1688
1689 // String length.
1690 const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy);
1691 Fields[2] = llvm::ConstantInt::get(Ty, StringLength);
1692
1693 // The struct.
1694 C = llvm::ConstantStruct::get(STy, Fields);
1695 GV = new llvm::GlobalVariable(getModule(), C->getType(), true,
1696 llvm::GlobalVariable::PrivateLinkage, C,
1697 "_unnamed_nsstring_");
1698 // FIXME. Fix section.
Fariborz Jahanianec951e02010-04-23 22:33:39 +00001699 if (const char *Sect =
1700 Features.ObjCNonFragileABI
1701 ? getContext().Target.getNSStringNonFragileABISection()
1702 : getContext().Target.getNSStringSection())
Fariborz Jahanian2bb5dda2010-04-23 17:41:07 +00001703 GV->setSection(Sect);
1704 Entry.setValue(GV);
1705
1706 return GV;
Fariborz Jahanian33e982b2010-04-22 20:26:39 +00001707}
1708
Daniel Dunbar61432932008-08-13 23:20:05 +00001709/// GetStringForStringLiteral - Return the appropriate bytes for a
Daniel Dunbar1e049762008-08-10 20:25:57 +00001710/// string literal, properly padded to match the literal type.
Daniel Dunbar61432932008-08-13 23:20:05 +00001711std::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) {
Daniel Dunbar1e049762008-08-10 20:25:57 +00001712 const ConstantArrayType *CAT =
1713 getContext().getAsConstantArrayType(E->getType());
1714 assert(CAT && "String isn't pointer or array!");
Mike Stump1eb44332009-09-09 15:08:12 +00001715
Chris Lattnerdbb1ecc2009-02-26 23:01:51 +00001716 // Resize the string to the right size.
Daniel Dunbar1e049762008-08-10 20:25:57 +00001717 uint64_t RealLen = CAT->getSize().getZExtValue();
Mike Stump1eb44332009-09-09 15:08:12 +00001718
Chris Lattnerdbb1ecc2009-02-26 23:01:51 +00001719 if (E->isWide())
1720 RealLen *= getContext().Target.getWCharWidth()/8;
Mike Stump1eb44332009-09-09 15:08:12 +00001721
Benjamin Kramer2f4eaef2010-08-17 12:54:38 +00001722 std::string Str = E->getString().str();
Daniel Dunbar1e049762008-08-10 20:25:57 +00001723 Str.resize(RealLen, '\0');
Mike Stump1eb44332009-09-09 15:08:12 +00001724
Daniel Dunbar1e049762008-08-10 20:25:57 +00001725 return Str;
1726}
1727
Daniel Dunbar61432932008-08-13 23:20:05 +00001728/// GetAddrOfConstantStringFromLiteral - Return a pointer to a
1729/// constant array for the given string literal.
1730llvm::Constant *
1731CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) {
1732 // FIXME: This can be more efficient.
Eli Friedman7eb79c12009-11-16 05:55:46 +00001733 // FIXME: We shouldn't need to bitcast the constant in the wide string case.
1734 llvm::Constant *C = GetAddrOfConstantString(GetStringForStringLiteral(S));
1735 if (S->isWide()) {
1736 llvm::Type *DestTy =
1737 llvm::PointerType::getUnqual(getTypes().ConvertType(S->getType()));
1738 C = llvm::ConstantExpr::getBitCast(C, DestTy);
1739 }
1740 return C;
Daniel Dunbar61432932008-08-13 23:20:05 +00001741}
1742
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001743/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
1744/// array for the given ObjCEncodeExpr node.
1745llvm::Constant *
1746CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) {
1747 std::string Str;
1748 getContext().getObjCEncodingForType(E->getEncodedType(), Str);
Eli Friedmana210f352009-03-07 20:17:55 +00001749
1750 return GetAddrOfConstantCString(Str);
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001751}
1752
1753
Chris Lattnera7ad98f2008-02-11 00:02:17 +00001754/// GenerateWritableString -- Creates storage for a string literal.
Mike Stump1eb44332009-09-09 15:08:12 +00001755static llvm::Constant *GenerateStringLiteral(const std::string &str,
Chris Lattner45e8cbd2007-11-28 05:34:05 +00001756 bool constant,
Daniel Dunbar5fabf9d2008-10-17 21:56:50 +00001757 CodeGenModule &CGM,
1758 const char *GlobalName) {
Daniel Dunbar61432932008-08-13 23:20:05 +00001759 // Create Constant for this string literal. Don't add a '\0'.
Owen Anderson0032b272009-08-13 21:57:51 +00001760 llvm::Constant *C =
1761 llvm::ConstantArray::get(CGM.getLLVMContext(), str, false);
Mike Stump1eb44332009-09-09 15:08:12 +00001762
Chris Lattner45e8cbd2007-11-28 05:34:05 +00001763 // Create a global variable for this string
Mike Stump1eb44332009-09-09 15:08:12 +00001764 return new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant,
Chris Lattner95b851e2009-07-16 05:03:48 +00001765 llvm::GlobalValue::PrivateLinkage,
Owen Anderson1c431b32009-07-08 19:05:04 +00001766 C, GlobalName);
Chris Lattner45e8cbd2007-11-28 05:34:05 +00001767}
1768
Daniel Dunbar61432932008-08-13 23:20:05 +00001769/// GetAddrOfConstantString - Returns a pointer to a character array
1770/// containing the literal. This contents are exactly that of the
1771/// given string, i.e. it will not be null terminated automatically;
1772/// see GetAddrOfConstantCString. Note that whether the result is
1773/// actually a pointer to an LLVM constant depends on
1774/// Feature.WriteableStrings.
1775///
1776/// The result has pointer to array type.
Daniel Dunbar5fabf9d2008-10-17 21:56:50 +00001777llvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str,
1778 const char *GlobalName) {
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00001779 bool IsConstant = !Features.WritableStrings;
1780
1781 // Get the default prefix if a name wasn't specified.
1782 if (!GlobalName)
Chris Lattner95b851e2009-07-16 05:03:48 +00001783 GlobalName = ".str";
Daniel Dunbar8e5c2b82009-03-31 23:42:16 +00001784
1785 // Don't share any string literals if strings aren't constant.
1786 if (!IsConstant)
Daniel Dunbar5fabf9d2008-10-17 21:56:50 +00001787 return GenerateStringLiteral(str, false, *this, GlobalName);
Mike Stump1eb44332009-09-09 15:08:12 +00001788
1789 llvm::StringMapEntry<llvm::Constant *> &Entry =
Chris Lattner95b851e2009-07-16 05:03:48 +00001790 ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]);
Chris Lattner45e8cbd2007-11-28 05:34:05 +00001791
1792 if (Entry.getValue())
Chris Lattnereaf2bb82009-02-24 22:18:39 +00001793 return Entry.getValue();
Chris Lattner45e8cbd2007-11-28 05:34:05 +00001794
1795 // Create a global variable for this.
Daniel Dunbar5fabf9d2008-10-17 21:56:50 +00001796 llvm::Constant *C = GenerateStringLiteral(str, true, *this, GlobalName);
Chris Lattner45e8cbd2007-11-28 05:34:05 +00001797 Entry.setValue(C);
1798 return C;
1799}
Daniel Dunbar61432932008-08-13 23:20:05 +00001800
1801/// GetAddrOfConstantCString - Returns a pointer to a character
1802/// array containing the literal and a terminating '\-'
1803/// character. The result has pointer to array type.
Daniel Dunbar5fabf9d2008-10-17 21:56:50 +00001804llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &str,
1805 const char *GlobalName){
Chris Lattnerc9f29c62008-12-09 19:10:54 +00001806 return GetAddrOfConstantString(str + '\0', GlobalName);
Daniel Dunbar61432932008-08-13 23:20:05 +00001807}
Daniel Dunbar41071de2008-08-15 23:26:23 +00001808
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001809/// EmitObjCPropertyImplementations - Emit information for synthesized
1810/// properties for an implementation.
Mike Stump1eb44332009-09-09 15:08:12 +00001811void CodeGenModule::EmitObjCPropertyImplementations(const
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001812 ObjCImplementationDecl *D) {
Mike Stump1eb44332009-09-09 15:08:12 +00001813 for (ObjCImplementationDecl::propimpl_iterator
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001814 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) {
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001815 ObjCPropertyImplDecl *PID = *i;
Mike Stump1eb44332009-09-09 15:08:12 +00001816
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001817 // Dynamic is just for type-checking.
1818 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
1819 ObjCPropertyDecl *PD = PID->getPropertyDecl();
1820
1821 // Determine which methods need to be implemented, some may have
1822 // been overridden. Note that ::isSynthesized is not the method
1823 // we want, that just indicates if the decl came from a
1824 // property. What we want to know is if the method is defined in
1825 // this implementation.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001826 if (!D->getInstanceMethod(PD->getGetterName()))
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00001827 CodeGenFunction(*this).GenerateObjCGetter(
1828 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001829 if (!PD->isReadOnly() &&
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001830 !D->getInstanceMethod(PD->getSetterName()))
Fariborz Jahanianfef30b52008-12-09 20:23:04 +00001831 CodeGenFunction(*this).GenerateObjCSetter(
1832 const_cast<ObjCImplementationDecl *>(D), PID);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001833 }
1834 }
1835}
1836
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00001837/// EmitObjCIvarInitializations - Emit information for ivar initialization
1838/// for an implementation.
1839void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
1840 if (!Features.NeXTRuntime || D->getNumIvarInitializers() == 0)
1841 return;
1842 DeclContext* DC = const_cast<DeclContext*>(dyn_cast<DeclContext>(D));
1843 assert(DC && "EmitObjCIvarInitializations - null DeclContext");
1844 IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
1845 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
1846 ObjCMethodDecl *DTORMethod = ObjCMethodDecl::Create(getContext(),
1847 D->getLocation(),
1848 D->getLocation(), cxxSelector,
1849 getContext().VoidTy, 0,
Fariborz Jahanian3fe10412010-07-22 18:24:20 +00001850 DC, true, false, true, false,
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00001851 ObjCMethodDecl::Required);
1852 D->addInstanceMethod(DTORMethod);
1853 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
1854
1855 II = &getContext().Idents.get(".cxx_construct");
1856 cxxSelector = getContext().Selectors.getSelector(0, &II);
1857 // The constructor returns 'self'.
1858 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(getContext(),
1859 D->getLocation(),
1860 D->getLocation(), cxxSelector,
1861 getContext().getObjCIdType(), 0,
Fariborz Jahanian3fe10412010-07-22 18:24:20 +00001862 DC, true, false, true, false,
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00001863 ObjCMethodDecl::Required);
1864 D->addInstanceMethod(CTORMethod);
1865 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
1866
1867
1868}
1869
Anders Carlsson91e20dd2009-04-02 05:55:18 +00001870/// EmitNamespace - Emit all declarations in a namespace.
Anders Carlsson984e0682009-04-01 00:58:25 +00001871void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) {
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001872 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end();
Anders Carlsson984e0682009-04-01 00:58:25 +00001873 I != E; ++I)
1874 EmitTopLevelDecl(*I);
1875}
1876
Anders Carlsson91e20dd2009-04-02 05:55:18 +00001877// EmitLinkageSpec - Emit all declarations in a linkage spec.
1878void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
Eli Friedmanf976be82009-08-01 20:48:04 +00001879 if (LSD->getLanguage() != LinkageSpecDecl::lang_c &&
1880 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) {
Anders Carlsson91e20dd2009-04-02 05:55:18 +00001881 ErrorUnsupported(LSD, "linkage spec");
1882 return;
1883 }
1884
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +00001885 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end();
Anders Carlsson91e20dd2009-04-02 05:55:18 +00001886 I != E; ++I)
1887 EmitTopLevelDecl(*I);
1888}
1889
Daniel Dunbar41071de2008-08-15 23:26:23 +00001890/// EmitTopLevelDecl - Emit code for a single top level declaration.
1891void CodeGenModule::EmitTopLevelDecl(Decl *D) {
1892 // If an error has occurred, stop code generation, but continue
1893 // parsing and semantic analysis (to ensure all warnings and errors
1894 // are emitted).
1895 if (Diags.hasErrorOccurred())
1896 return;
1897
Douglas Gregor16e8be22009-06-29 17:30:29 +00001898 // Ignore dependent declarations.
1899 if (D->getDeclContext() && D->getDeclContext()->isDependentContext())
1900 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001901
Daniel Dunbar41071de2008-08-15 23:26:23 +00001902 switch (D->getKind()) {
Anders Carlsson293361a2009-08-25 13:14:46 +00001903 case Decl::CXXConversion:
Anders Carlsson2b77ba82009-04-04 20:47:02 +00001904 case Decl::CXXMethod:
Daniel Dunbar41071de2008-08-15 23:26:23 +00001905 case Decl::Function:
Douglas Gregor16e8be22009-06-29 17:30:29 +00001906 // Skip function templates
1907 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate())
1908 return;
Mike Stump1eb44332009-09-09 15:08:12 +00001909
Anders Carlsson555b4bb2009-09-10 23:43:36 +00001910 EmitGlobal(cast<FunctionDecl>(D));
1911 break;
1912
Daniel Dunbar41071de2008-08-15 23:26:23 +00001913 case Decl::Var:
Anders Carlsson555b4bb2009-09-10 23:43:36 +00001914 EmitGlobal(cast<VarDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00001915 break;
1916
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00001917 // C++ Decls
Daniel Dunbar41071de2008-08-15 23:26:23 +00001918 case Decl::Namespace:
Anders Carlsson984e0682009-04-01 00:58:25 +00001919 EmitNamespace(cast<NamespaceDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00001920 break;
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001921 // No code generation needed.
John McCall9d0c6612009-11-17 09:33:40 +00001922 case Decl::UsingShadow:
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001923 case Decl::Using:
Douglas Gregordd9967a2009-09-02 23:49:23 +00001924 case Decl::UsingDirective:
Douglas Gregor127102b2009-06-29 20:59:39 +00001925 case Decl::ClassTemplate:
1926 case Decl::FunctionTemplate:
Anders Carlsson018837b2009-09-23 19:19:16 +00001927 case Decl::NamespaceAlias:
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001928 break;
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00001929 case Decl::CXXConstructor:
Anders Carlsson1fe598c2009-11-24 05:16:24 +00001930 // Skip function templates
1931 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate())
1932 return;
1933
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00001934 EmitCXXConstructors(cast<CXXConstructorDecl>(D));
1935 break;
Anders Carlsson27ae5362009-04-17 01:58:57 +00001936 case Decl::CXXDestructor:
1937 EmitCXXDestructors(cast<CXXDestructorDecl>(D));
1938 break;
Anders Carlsson36674d22009-06-11 21:22:55 +00001939
1940 case Decl::StaticAssert:
1941 // Nothing to do.
1942 break;
1943
Anders Carlsson95d4e5d2009-04-15 15:55:24 +00001944 // Objective-C Decls
Mike Stump1eb44332009-09-09 15:08:12 +00001945
Fariborz Jahanian38e24c72009-03-18 22:33:24 +00001946 // Forward declarations, no (immediate) code generation.
Daniel Dunbar41071de2008-08-15 23:26:23 +00001947 case Decl::ObjCClass:
Daniel Dunbar41071de2008-08-15 23:26:23 +00001948 case Decl::ObjCForwardProtocol:
Fariborz Jahanianb31cb7f2009-03-21 18:06:45 +00001949 case Decl::ObjCCategory:
Chris Lattner285d0db2009-04-01 02:36:43 +00001950 case Decl::ObjCInterface:
Chris Lattner285d0db2009-04-01 02:36:43 +00001951 break;
1952
Daniel Dunbar41071de2008-08-15 23:26:23 +00001953 case Decl::ObjCProtocol:
Fariborz Jahanianb31cb7f2009-03-21 18:06:45 +00001954 Runtime->GenerateProtocol(cast<ObjCProtocolDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00001955 break;
1956
1957 case Decl::ObjCCategoryImpl:
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001958 // Categories have properties but don't support synthesize so we
1959 // can ignore them here.
Daniel Dunbar41071de2008-08-15 23:26:23 +00001960 Runtime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
1961 break;
1962
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001963 case Decl::ObjCImplementation: {
1964 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D);
1965 EmitObjCPropertyImplementations(OMD);
Fariborz Jahanian109dfc62010-04-28 21:28:56 +00001966 EmitObjCIvarInitializations(OMD);
Daniel Dunbaraf05bb92008-08-26 08:29:31 +00001967 Runtime->GenerateClass(OMD);
Daniel Dunbar41071de2008-08-15 23:26:23 +00001968 break;
Mike Stump1eb44332009-09-09 15:08:12 +00001969 }
Daniel Dunbar41071de2008-08-15 23:26:23 +00001970 case Decl::ObjCMethod: {
1971 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D);
1972 // If this is not a prototype, emit the body.
Argyrios Kyrtzidis6fb0aee2009-06-30 02:35:26 +00001973 if (OMD->getBody())
Daniel Dunbar41071de2008-08-15 23:26:23 +00001974 CodeGenFunction(*this).GenerateObjCMethod(OMD);
1975 break;
1976 }
Mike Stump1eb44332009-09-09 15:08:12 +00001977 case Decl::ObjCCompatibleAlias:
Fariborz Jahanian305c6582009-01-08 01:10:55 +00001978 // compatibility-alias is a directive and has no code gen.
Daniel Dunbar41071de2008-08-15 23:26:23 +00001979 break;
1980
Anders Carlsson91e20dd2009-04-02 05:55:18 +00001981 case Decl::LinkageSpec:
1982 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
Daniel Dunbar41071de2008-08-15 23:26:23 +00001983 break;
Daniel Dunbar41071de2008-08-15 23:26:23 +00001984
1985 case Decl::FileScopeAsm: {
1986 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D);
Benjamin Kramer8d042582009-12-11 13:33:18 +00001987 llvm::StringRef AsmString = AD->getAsmString()->getString();
Mike Stump1eb44332009-09-09 15:08:12 +00001988
Daniel Dunbar41071de2008-08-15 23:26:23 +00001989 const std::string &S = getModule().getModuleInlineAsm();
1990 if (S.empty())
1991 getModule().setModuleInlineAsm(AsmString);
1992 else
Benjamin Kramer8d042582009-12-11 13:33:18 +00001993 getModule().setModuleInlineAsm(S + '\n' + AsmString.str());
Daniel Dunbar41071de2008-08-15 23:26:23 +00001994 break;
1995 }
Mike Stump1eb44332009-09-09 15:08:12 +00001996
1997 default:
Mike Stumpf5408fe2009-05-16 07:57:57 +00001998 // Make sure we handled everything we should, every other kind is a
1999 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
2000 // function. Need to recode Decl::Kind to do that easily.
Daniel Dunbar41071de2008-08-15 23:26:23 +00002001 assert(isa<TypeDecl>(D) && "Unsupported decl kind");
2002 }
2003}
John McCall744016d2010-07-06 23:57:41 +00002004
2005/// Turns the given pointer into a constant.
2006static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
2007 const void *Ptr) {
2008 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
2009 const llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
2010 return llvm::ConstantInt::get(i64, PtrInt);
2011}
2012
2013static void EmitGlobalDeclMetadata(CodeGenModule &CGM,
2014 llvm::NamedMDNode *&GlobalMetadata,
2015 GlobalDecl D,
2016 llvm::GlobalValue *Addr) {
2017 if (!GlobalMetadata)
2018 GlobalMetadata =
2019 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
2020
2021 // TODO: should we report variant information for ctors/dtors?
2022 llvm::Value *Ops[] = {
2023 Addr,
2024 GetPointerConstant(CGM.getLLVMContext(), D.getDecl())
2025 };
2026 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops, 2));
2027}
2028
2029/// Emits metadata nodes associating all the global values in the
2030/// current module with the Decls they came from. This is useful for
2031/// projects using IR gen as a subroutine.
2032///
2033/// Since there's currently no way to associate an MDNode directly
2034/// with an llvm::GlobalValue, we create a global named metadata
2035/// with the name 'clang.global.decl.ptrs'.
2036void CodeGenModule::EmitDeclMetadata() {
2037 llvm::NamedMDNode *GlobalMetadata = 0;
2038
2039 // StaticLocalDeclMap
2040 for (llvm::DenseMap<GlobalDecl,llvm::StringRef>::iterator
2041 I = MangledDeclNames.begin(), E = MangledDeclNames.end();
2042 I != E; ++I) {
2043 llvm::GlobalValue *Addr = getModule().getNamedValue(I->second);
2044 EmitGlobalDeclMetadata(*this, GlobalMetadata, I->first, Addr);
2045 }
2046}
2047
2048/// Emits metadata nodes for all the local variables in the current
2049/// function.
2050void CodeGenFunction::EmitDeclMetadata() {
2051 if (LocalDeclMap.empty()) return;
2052
2053 llvm::LLVMContext &Context = getLLVMContext();
2054
2055 // Find the unique metadata ID for this name.
2056 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
2057
2058 llvm::NamedMDNode *GlobalMetadata = 0;
2059
2060 for (llvm::DenseMap<const Decl*, llvm::Value*>::iterator
2061 I = LocalDeclMap.begin(), E = LocalDeclMap.end(); I != E; ++I) {
2062 const Decl *D = I->first;
2063 llvm::Value *Addr = I->second;
2064
2065 if (llvm::AllocaInst *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
2066 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
2067 Alloca->setMetadata(DeclPtrKind, llvm::MDNode::get(Context, &DAddr, 1));
2068 } else if (llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
2069 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
2070 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
2071 }
2072 }
2073}
Daniel Dunbar673431a2010-07-16 00:00:15 +00002074
2075///@name Custom Runtime Function Interfaces
2076///@{
2077//
2078// FIXME: These can be eliminated once we can have clients just get the required
2079// AST nodes from the builtin tables.
2080
2081llvm::Constant *CodeGenModule::getBlockObjectDispose() {
2082 if (BlockObjectDispose)
2083 return BlockObjectDispose;
2084
Daniel Dunbar754b9fb2010-07-16 00:00:19 +00002085 // If we saw an explicit decl, use that.
2086 if (BlockObjectDisposeDecl) {
2087 return BlockObjectDispose = GetAddrOfFunction(
2088 BlockObjectDisposeDecl,
2089 getTypes().GetFunctionType(BlockObjectDisposeDecl));
2090 }
2091
2092 // Otherwise construct the function by hand.
Daniel Dunbar673431a2010-07-16 00:00:15 +00002093 const llvm::FunctionType *FTy;
2094 std::vector<const llvm::Type*> ArgTys;
2095 const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext);
2096 ArgTys.push_back(PtrToInt8Ty);
2097 ArgTys.push_back(llvm::Type::getInt32Ty(VMContext));
2098 FTy = llvm::FunctionType::get(ResultType, ArgTys, false);
2099 return BlockObjectDispose =
2100 CreateRuntimeFunction(FTy, "_Block_object_dispose");
2101}
2102
2103llvm::Constant *CodeGenModule::getBlockObjectAssign() {
2104 if (BlockObjectAssign)
2105 return BlockObjectAssign;
2106
Daniel Dunbar754b9fb2010-07-16 00:00:19 +00002107 // If we saw an explicit decl, use that.
2108 if (BlockObjectAssignDecl) {
2109 return BlockObjectAssign = GetAddrOfFunction(
2110 BlockObjectAssignDecl,
2111 getTypes().GetFunctionType(BlockObjectAssignDecl));
2112 }
2113
2114 // Otherwise construct the function by hand.
Daniel Dunbar673431a2010-07-16 00:00:15 +00002115 const llvm::FunctionType *FTy;
2116 std::vector<const llvm::Type*> ArgTys;
2117 const llvm::Type *ResultType = llvm::Type::getVoidTy(VMContext);
2118 ArgTys.push_back(PtrToInt8Ty);
2119 ArgTys.push_back(PtrToInt8Ty);
2120 ArgTys.push_back(llvm::Type::getInt32Ty(VMContext));
2121 FTy = llvm::FunctionType::get(ResultType, ArgTys, false);
2122 return BlockObjectAssign =
2123 CreateRuntimeFunction(FTy, "_Block_object_assign");
2124}
2125
2126llvm::Constant *CodeGenModule::getNSConcreteGlobalBlock() {
2127 if (NSConcreteGlobalBlock)
2128 return NSConcreteGlobalBlock;
Daniel Dunbar754b9fb2010-07-16 00:00:19 +00002129
2130 // If we saw an explicit decl, use that.
2131 if (NSConcreteGlobalBlockDecl) {
2132 return NSConcreteGlobalBlock = GetAddrOfGlobalVar(
2133 NSConcreteGlobalBlockDecl,
2134 getTypes().ConvertType(NSConcreteGlobalBlockDecl->getType()));
2135 }
2136
2137 // Otherwise construct the variable by hand.
Daniel Dunbar673431a2010-07-16 00:00:15 +00002138 return NSConcreteGlobalBlock = CreateRuntimeVariable(
2139 PtrToInt8Ty, "_NSConcreteGlobalBlock");
2140}
2141
2142llvm::Constant *CodeGenModule::getNSConcreteStackBlock() {
2143 if (NSConcreteStackBlock)
2144 return NSConcreteStackBlock;
Daniel Dunbar754b9fb2010-07-16 00:00:19 +00002145
2146 // If we saw an explicit decl, use that.
2147 if (NSConcreteStackBlockDecl) {
2148 return NSConcreteStackBlock = GetAddrOfGlobalVar(
2149 NSConcreteStackBlockDecl,
2150 getTypes().ConvertType(NSConcreteStackBlockDecl->getType()));
2151 }
2152
2153 // Otherwise construct the variable by hand.
Daniel Dunbar673431a2010-07-16 00:00:15 +00002154 return NSConcreteStackBlock = CreateRuntimeVariable(
2155 PtrToInt8Ty, "_NSConcreteStackBlock");
2156}
2157
2158///@}