blob: 790db1a7bf0635a7585a1605ab7da36013835b33 [file] [log] [blame]
Chris Lattner84915fa2007-06-02 04:16:21 +00001//===--- CGDecl.cpp - Emit LLVM Code for declarations ---------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner84915fa2007-06-02 04:16:21 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Decl nodes as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
John McCall7f416cc2015-09-08 08:05:57 +000014#include "CGBlocks.h"
Reid Klecknere5a321b2016-09-07 18:21:30 +000015#include "CGCXXABI.h"
David Majnemerdc012fa2015-04-22 21:38:15 +000016#include "CGCleanup.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000017#include "CGDebugInfo.h"
Peter Collingbourne2dbb7082011-09-19 21:14:35 +000018#include "CGOpenCLRuntime.h"
Alexey Bataevc5b1d322016-03-04 09:22:22 +000019#include "CGOpenMPRuntime.h"
Yaxun Liu6d96f1632017-05-18 18:51:09 +000020#include "CodeGenFunction.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000021#include "CodeGenModule.h"
John McCallde0fe072017-08-15 21:42:52 +000022#include "ConstantEmitter.h"
Yaxun Liu6d96f1632017-05-18 18:51:09 +000023#include "TargetInfo.h"
Daniel Dunbarad319a72008-08-11 05:00:27 +000024#include "clang/AST/ASTContext.h"
Ken Dyck8c89d592009-12-22 14:23:30 +000025#include "clang/AST/CharUnits.h"
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000026#include "clang/AST/Decl.h"
Anders Carlsson4c03d982008-08-25 01:38:19 +000027#include "clang/AST/DeclObjC.h"
Alexey Bataev94a4f0c2016-03-03 05:21:39 +000028#include "clang/AST/DeclOpenMP.h"
Nate Begemanfaae0812008-04-19 04:17:09 +000029#include "clang/Basic/SourceManager.h"
Chris Lattnerb781dc792008-05-08 05:58:21 +000030#include "clang/Basic/TargetInfo.h"
Mark Laceya8e7df32013-10-30 21:53:58 +000031#include "clang/CodeGen/CGFunctionInfo.h"
Saleem Abdulrasool10a49722016-04-08 16:52:00 +000032#include "clang/Frontend/CodeGenOptions.h"
Chandler Carruthffd55512013-01-02 11:45:17 +000033#include "llvm/IR/DataLayout.h"
34#include "llvm/IR/GlobalVariable.h"
35#include "llvm/IR/Intrinsics.h"
36#include "llvm/IR/Type.h"
Eugene Zelenko0a4f3f42016-02-10 19:11:58 +000037
Chris Lattner84915fa2007-06-02 04:16:21 +000038using namespace clang;
39using namespace CodeGen;
40
Chris Lattner1ad38f82007-06-09 01:20:56 +000041void CodeGenFunction::EmitDecl(const Decl &D) {
Chris Lattner1ad38f82007-06-09 01:20:56 +000042 switch (D.getKind()) {
David Majnemerd9b1a4f2015-11-04 03:40:30 +000043 case Decl::BuiltinTemplate:
Douglas Gregor19043f02010-04-23 02:02:43 +000044 case Decl::TranslationUnit:
Richard Smithf19e1272015-03-07 00:04:49 +000045 case Decl::ExternCContext:
Douglas Gregor19043f02010-04-23 02:02:43 +000046 case Decl::Namespace:
47 case Decl::UnresolvedUsingTypename:
48 case Decl::ClassTemplateSpecialization:
49 case Decl::ClassTemplatePartialSpecialization:
Larisse Voufo39a1e502013-08-06 01:03:05 +000050 case Decl::VarTemplateSpecialization:
51 case Decl::VarTemplatePartialSpecialization:
Douglas Gregor19043f02010-04-23 02:02:43 +000052 case Decl::TemplateTypeParm:
53 case Decl::UnresolvedUsingValue:
Alexis Hunted053252010-05-30 07:21:58 +000054 case Decl::NonTypeTemplateParm:
Richard Smithbc491202017-02-17 20:05:37 +000055 case Decl::CXXDeductionGuide:
Douglas Gregor19043f02010-04-23 02:02:43 +000056 case Decl::CXXMethod:
57 case Decl::CXXConstructor:
58 case Decl::CXXDestructor:
59 case Decl::CXXConversion:
60 case Decl::Field:
John McCall5e77d762013-04-16 07:28:30 +000061 case Decl::MSProperty:
Francois Pichetdf946c32010-11-21 06:49:41 +000062 case Decl::IndirectField:
Douglas Gregor19043f02010-04-23 02:02:43 +000063 case Decl::ObjCIvar:
Eric Christopher31ab1302011-08-23 22:38:00 +000064 case Decl::ObjCAtDefsField:
Chris Lattnerba9dddb2007-10-08 21:37:32 +000065 case Decl::ParmVar:
Douglas Gregor19043f02010-04-23 02:02:43 +000066 case Decl::ImplicitParam:
67 case Decl::ClassTemplate:
Larisse Voufo39a1e502013-08-06 01:03:05 +000068 case Decl::VarTemplate:
Douglas Gregor19043f02010-04-23 02:02:43 +000069 case Decl::FunctionTemplate:
Richard Smith3f1b5d02011-05-05 21:57:07 +000070 case Decl::TypeAliasTemplate:
Douglas Gregor19043f02010-04-23 02:02:43 +000071 case Decl::TemplateTemplateParm:
72 case Decl::ObjCMethod:
73 case Decl::ObjCCategory:
74 case Decl::ObjCProtocol:
75 case Decl::ObjCInterface:
76 case Decl::ObjCCategoryImpl:
77 case Decl::ObjCImplementation:
78 case Decl::ObjCProperty:
79 case Decl::ObjCCompatibleAlias:
Nico Weber66220292016-03-02 17:28:48 +000080 case Decl::PragmaComment:
Nico Webercbbaeb12016-03-02 19:28:54 +000081 case Decl::PragmaDetectMismatch:
Abramo Bagnarad7340582010-06-05 05:09:32 +000082 case Decl::AccessSpec:
Douglas Gregor19043f02010-04-23 02:02:43 +000083 case Decl::LinkageSpec:
Richard Smith8df390f2016-09-08 23:14:54 +000084 case Decl::Export:
Douglas Gregor19043f02010-04-23 02:02:43 +000085 case Decl::ObjCPropertyImpl:
Douglas Gregor19043f02010-04-23 02:02:43 +000086 case Decl::FileScopeAsm:
87 case Decl::Friend:
88 case Decl::FriendTemplate:
89 case Decl::Block:
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +000090 case Decl::Captured:
Francois Pichet00c7e6c2011-08-14 03:52:19 +000091 case Decl::ClassScopeFunctionSpecialization:
David Blaikiebd483762013-05-20 04:58:53 +000092 case Decl::UsingShadow:
Richard Smith5179eb72016-06-28 19:03:57 +000093 case Decl::ConstructorUsingShadow:
Douglas Gregor85f3f952015-07-07 03:57:15 +000094 case Decl::ObjCTypeParam:
Richard Smithda383632016-08-15 01:33:41 +000095 case Decl::Binding:
David Blaikie83d382b2011-09-23 05:06:16 +000096 llvm_unreachable("Declaration should not be in declstmts!");
Amjad Abouddc4531e2016-04-30 01:44:38 +000097 case Decl::Function: // void X();
98 case Decl::Record: // struct/union/class X;
99 case Decl::Enum: // enum X;
100 case Decl::EnumConstant: // enum ? { X = ? }
101 case Decl::CXXRecord: // struct/union/class X; [C++]
Anders Carlssonce2cd012009-12-03 17:26:31 +0000102 case Decl::StaticAssert: // static_assert(X, ""); [C++0x]
Chris Lattner43e7f312011-02-18 02:08:43 +0000103 case Decl::Label: // __label__ x;
Douglas Gregorba345522011-12-02 23:23:56 +0000104 case Decl::Import:
Alexey Bataeva769e072013-03-22 06:34:35 +0000105 case Decl::OMPThreadPrivate:
Alexey Bataev4244be22016-02-11 05:35:55 +0000106 case Decl::OMPCapturedExpr:
Michael Han84324352013-02-22 17:15:32 +0000107 case Decl::Empty:
Chris Lattner84915fa2007-06-02 04:16:21 +0000108 // None of these decls require codegen support.
109 return;
David Blaikieb7d1e1f2013-02-02 00:39:32 +0000110
David Blaikief121b932013-05-20 22:50:41 +0000111 case Decl::NamespaceAlias:
112 if (CGDebugInfo *DI = getDebugInfo())
Amjad Abouddc4531e2016-04-30 01:44:38 +0000113 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(D));
David Blaikief121b932013-05-20 22:50:41 +0000114 return;
David Blaikiebd483762013-05-20 04:58:53 +0000115 case Decl::Using: // using X; [C++]
116 if (CGDebugInfo *DI = getDebugInfo())
Amjad Abouddc4531e2016-04-30 01:44:38 +0000117 DI->EmitUsingDecl(cast<UsingDecl>(D));
David Blaikiebd483762013-05-20 04:58:53 +0000118 return;
Richard Smith151c4562016-12-20 21:35:28 +0000119 case Decl::UsingPack:
120 for (auto *Using : cast<UsingPackDecl>(D).expansions())
121 EmitDecl(*Using);
122 return;
David Blaikie9f88fe82013-04-22 06:13:21 +0000123 case Decl::UsingDirective: // using namespace X; [C++]
124 if (CGDebugInfo *DI = getDebugInfo())
125 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(D));
126 return;
Richard Smithbdb84f32016-07-22 23:36:59 +0000127 case Decl::Var:
128 case Decl::Decomposition: {
Daniel Dunbara7998072008-08-29 17:28:43 +0000129 const VarDecl &VD = cast<VarDecl>(D);
John McCall1c9c3fd2010-10-15 04:57:14 +0000130 assert(VD.isLocalVarDecl() &&
Daniel Dunbara7998072008-08-29 17:28:43 +0000131 "Should not see file-scope variables inside a function!");
Richard Smithda383632016-08-15 01:33:41 +0000132 EmitVarDecl(VD);
133 if (auto *DD = dyn_cast<DecompositionDecl>(&VD))
134 for (auto *B : DD->bindings())
135 if (auto *HD = B->getHoldingVar())
136 EmitVarDecl(*HD);
137 return;
Chris Lattner84915fa2007-06-02 04:16:21 +0000138 }
Mike Stump11289f42009-09-09 15:08:12 +0000139
Alexey Bataev94a4f0c2016-03-03 05:21:39 +0000140 case Decl::OMPDeclareReduction:
Alexey Bataevc5b1d322016-03-04 09:22:22 +0000141 return CGM.EmitOMPDeclareReduction(cast<OMPDeclareReductionDecl>(&D), this);
Alexey Bataev94a4f0c2016-03-03 05:21:39 +0000142
Richard Smithdda56e42011-04-15 14:24:37 +0000143 case Decl::Typedef: // typedef int X;
144 case Decl::TypeAlias: { // using X = int; [C++0x]
145 const TypedefNameDecl &TD = cast<TypedefNameDecl>(D);
Anders Carlsson5d985f52008-12-20 21:51:53 +0000146 QualType Ty = TD.getUnderlyingType();
Mike Stump11289f42009-09-09 15:08:12 +0000147
Anders Carlsson5d985f52008-12-20 21:51:53 +0000148 if (Ty->isVariablyModifiedType())
John McCall23c29fe2011-06-24 21:55:10 +0000149 EmitVariablyModifiedType(Ty);
Anders Carlsson5d985f52008-12-20 21:51:53 +0000150 }
Daniel Dunbara7998072008-08-29 17:28:43 +0000151 }
Chris Lattner84915fa2007-06-02 04:16:21 +0000152}
Chris Lattner03df1222007-06-02 04:53:11 +0000153
John McCall1c9c3fd2010-10-15 04:57:14 +0000154/// EmitVarDecl - This method handles emission of any variable declaration
Chris Lattner03df1222007-06-02 04:53:11 +0000155/// inside a function, including static vars etc.
John McCall1c9c3fd2010-10-15 04:57:14 +0000156void CodeGenFunction::EmitVarDecl(const VarDecl &D) {
Yaxun Liu4f33b3d2017-05-15 14:47:47 +0000157 if (D.hasExternalStorage())
158 // Don't emit it now, allow it to be emitted lazily on its first use.
159 return;
160
161 // Some function-scope variable does not have static storage but still
162 // needs to be emitted like a static variable, e.g. a function-scope
163 // variable in constant address space in OpenCL.
164 if (D.getStorageDuration() != SD_Automatic) {
Alexey Baderbed40092017-11-15 11:38:17 +0000165 // Static sampler variables translated to function calls.
166 if (D.getType()->isSamplerT())
167 return;
168
Eric Christopher31ab1302011-08-23 22:38:00 +0000169 llvm::GlobalValue::LinkageTypes Linkage =
David Majnemer27d69db2014-04-28 22:17:59 +0000170 CGM.getLLVMLinkageVarDefinition(&D, /*isConstant=*/false);
Anders Carlssoncee2d2f2010-02-07 02:03:08 +0000171
David Majnemer27d69db2014-04-28 22:17:59 +0000172 // FIXME: We need to force the emission/use of a guard variable for
173 // some variables even if we can constant-evaluate them because
174 // we can't guarantee every translation unit will constant-evaluate them.
Eric Christopher31ab1302011-08-23 22:38:00 +0000175
John McCall1c9c3fd2010-10-15 04:57:14 +0000176 return EmitStaticVarDecl(D, Linkage);
Anders Carlssoncee2d2f2010-02-07 02:03:08 +0000177 }
Enea Zaffanellacf51a8a2013-05-16 11:27:56 +0000178
Anastasia Stulovabcea6962015-09-30 14:08:20 +0000179 if (D.getType().getAddressSpace() == LangAS::opencl_local)
Enea Zaffanellacf51a8a2013-05-16 11:27:56 +0000180 return CGM.getOpenCLRuntime().EmitWorkGroupLocalVarDecl(*this, D);
181
182 assert(D.hasLocalStorage());
183 return EmitAutoVarDecl(D);
Chris Lattner03df1222007-06-02 04:53:11 +0000184}
185
Reid Kleckner453e0562014-10-08 01:07:54 +0000186static std::string getStaticDeclName(CodeGenModule &CGM, const VarDecl &D) {
187 if (CGM.getLangOpts().CPlusPlus)
Alp Tokerfb8d02b2014-06-05 22:10:59 +0000188 return CGM.getMangledName(&D).str();
189
Reid Kleckner453e0562014-10-08 01:07:54 +0000190 // If this isn't C++, we don't need a mangled name, just a pretty one.
191 assert(!D.isExternallyVisible() && "name shouldn't matter");
192 std::string ContextName;
193 const DeclContext *DC = D.getDeclContext();
Alexey Bataev43f74392015-05-07 06:28:46 +0000194 if (auto *CD = dyn_cast<CapturedDecl>(DC))
195 DC = cast<DeclContext>(CD->getNonClosureContext());
Reid Kleckner453e0562014-10-08 01:07:54 +0000196 if (const auto *FD = dyn_cast<FunctionDecl>(DC))
Alp Tokerfb8d02b2014-06-05 22:10:59 +0000197 ContextName = CGM.getMangledName(FD);
Reid Kleckner453e0562014-10-08 01:07:54 +0000198 else if (const auto *BD = dyn_cast<BlockDecl>(DC))
199 ContextName = CGM.getBlockMangledName(GlobalDecl(), BD);
200 else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(DC))
201 ContextName = OMD->getSelector().getAsString();
Chris Lattnere99c1102009-12-05 08:22:11 +0000202 else
David Blaikie83d382b2011-09-23 05:06:16 +0000203 llvm_unreachable("Unknown context for static var decl");
Eric Christopher31ab1302011-08-23 22:38:00 +0000204
Reid Kleckner453e0562014-10-08 01:07:54 +0000205 ContextName += "." + D.getNameAsString();
206 return ContextName;
Chris Lattnere99c1102009-12-05 08:22:11 +0000207}
208
Reid Kleckner453e0562014-10-08 01:07:54 +0000209llvm::Constant *CodeGenModule::getOrCreateStaticVarDecl(
210 const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage) {
211 // In general, we don't always emit static var decls once before we reference
212 // them. It is possible to reference them before emitting the function that
213 // contains them, and it is possible to emit the containing function multiple
214 // times.
215 if (llvm::Constant *ExistingGV = StaticLocalDeclMap[&D])
216 return ExistingGV;
217
Chris Lattnerfc4379f2008-04-06 23:10:54 +0000218 QualType Ty = D.getType();
Eli Friedmana682d392008-02-15 12:20:59 +0000219 assert(Ty->isConstantSizeType() && "VLAs can't be static");
Nate Begemanfaae0812008-04-19 04:17:09 +0000220
Benjamin Kramerddbb2b82011-11-20 21:05:04 +0000221 // Use the label if the variable is renamed with the asm-label extension.
222 std::string Name;
Benjamin Kramer5642e192011-11-21 15:47:23 +0000223 if (D.hasAttr<AsmLabelAttr>())
Reid Kleckner453e0562014-10-08 01:07:54 +0000224 Name = getMangledName(&D);
Benjamin Kramer5642e192011-11-21 15:47:23 +0000225 else
Reid Kleckner453e0562014-10-08 01:07:54 +0000226 Name = getStaticDeclName(*this, D);
Nate Begemanfaae0812008-04-19 04:17:09 +0000227
Reid Kleckner453e0562014-10-08 01:07:54 +0000228 llvm::Type *LTy = getTypes().ConvertTypeForMem(Ty);
Alexander Richardson6d989432017-10-15 18:48:14 +0000229 LangAS AS = GetGlobalVarAddressSpace(&D);
Yaxun Liucbf647c2017-07-08 13:24:52 +0000230 unsigned TargetAS = getContext().getTargetAddressSpace(AS);
Matt Arsenault3f6469b2014-11-03 16:51:53 +0000231
232 // Local address space cannot have an initializer.
233 llvm::Constant *Init = nullptr;
234 if (Ty.getAddressSpace() != LangAS::opencl_local)
235 Init = EmitNullConstant(Ty);
236 else
237 Init = llvm::UndefValue::get(LTy);
238
Yaxun Liucbf647c2017-07-08 13:24:52 +0000239 llvm::GlobalVariable *GV = new llvm::GlobalVariable(
240 getModule(), LTy, Ty.isConstant(getContext()), Linkage, Init, Name,
241 nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
Ken Dyck160146e2010-01-27 17:10:57 +0000242 GV->setAlignment(getContext().getDeclAlign(&D).getQuantity());
Hans Wennborgf60f6af2012-06-28 08:01:44 +0000243
NAKAMURA Takumic7da6da2015-05-09 21:10:07 +0000244 if (supportsCOMDAT() && GV->isWeakForLinker())
245 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
Rafael Espindola0d4fb982015-01-12 22:13:53 +0000246
Richard Smithfd3834f2013-04-13 02:43:54 +0000247 if (D.getTLSKind())
Reid Kleckner453e0562014-10-08 01:07:54 +0000248 setTLSMode(GV, D);
Hans Wennborgf60f6af2012-06-28 08:01:44 +0000249
Rafael Espindola922f2aa2018-02-23 19:30:48 +0000250 setGVProperties(GV, &D);
251
Eli Benderskycb399432014-03-24 22:05:38 +0000252 // Make sure the result is of the correct type.
Alexander Richardson6d989432017-10-15 18:48:14 +0000253 LangAS ExpectedAS = Ty.getAddressSpace();
Reid Kleckner453e0562014-10-08 01:07:54 +0000254 llvm::Constant *Addr = GV;
Yaxun Liucbf647c2017-07-08 13:24:52 +0000255 if (AS != ExpectedAS) {
256 Addr = getTargetCodeGenInfo().performAddrSpaceCast(
257 *this, GV, AS, ExpectedAS,
258 LTy->getPointerTo(getContext().getTargetAddressSpace(ExpectedAS)));
Eli Benderskycb399432014-03-24 22:05:38 +0000259 }
260
Reid Kleckner453e0562014-10-08 01:07:54 +0000261 setStaticLocalDeclAddress(&D, Addr);
262
263 // Ensure that the static local gets initialized by making sure the parent
264 // function gets emitted eventually.
265 const Decl *DC = cast<Decl>(D.getDeclContext());
266
267 // We can't name blocks or captured statements directly, so try to emit their
268 // parents.
269 if (isa<BlockDecl>(DC) || isa<CapturedDecl>(DC)) {
270 DC = DC->getNonClosureContext();
271 // FIXME: Ensure that global blocks get emitted.
272 if (!DC)
273 return Addr;
274 }
275
276 GlobalDecl GD;
277 if (const auto *CD = dyn_cast<CXXConstructorDecl>(DC))
278 GD = GlobalDecl(CD, Ctor_Base);
279 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(DC))
280 GD = GlobalDecl(DD, Dtor_Base);
281 else if (const auto *FD = dyn_cast<FunctionDecl>(DC))
282 GD = GlobalDecl(FD);
283 else {
284 // Don't do anything for Obj-C method decls or global closures. We should
285 // never defer them.
286 assert(isa<ObjCMethodDecl>(DC) && "unexpected parent code decl");
287 }
Alexey Bataev4f4bf7c2018-03-15 15:47:20 +0000288 if (GD.getDecl()) {
289 // Disable emission of the parent function for the OpenMP device codegen.
290 CGOpenMPRuntime::DisableAutoDeclareTargetRAII NoDeclTarget(*this);
Reid Kleckner453e0562014-10-08 01:07:54 +0000291 (void)GetAddrOfGlobal(GD);
Alexey Bataev4f4bf7c2018-03-15 15:47:20 +0000292 }
Reid Kleckner453e0562014-10-08 01:07:54 +0000293
294 return Addr;
Daniel Dunbar22a87f92009-02-25 19:24:29 +0000295}
296
Richard Smith6331c402012-02-13 22:16:19 +0000297/// hasNontrivialDestruction - Determine whether a type's destruction is
298/// non-trivial. If so, and the variable uses static initialization, we must
299/// register its destructor to run on exit.
300static bool hasNontrivialDestruction(QualType T) {
301 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
302 return RD && !RD->hasTrivialDestructor();
303}
304
Chandler Carruth84537952012-03-30 19:44:53 +0000305/// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
306/// global variable that has already been created for it. If the initializer
307/// has a different type than GV does, this may free GV and return a different
308/// one. Otherwise it just returns GV.
309llvm::GlobalVariable *
John McCall1c9c3fd2010-10-15 04:57:14 +0000310CodeGenFunction::AddInitializerToStaticVarDecl(const VarDecl &D,
Chandler Carruth84537952012-03-30 19:44:53 +0000311 llvm::GlobalVariable *GV) {
John McCallde0fe072017-08-15 21:42:52 +0000312 ConstantEmitter emitter(*this);
313 llvm::Constant *Init = emitter.tryEmitForInitializer(D);
John McCall70013b62010-07-15 23:40:35 +0000314
Chris Lattnere99c1102009-12-05 08:22:11 +0000315 // If constant emission failed, then this should be a C++ static
316 // initializer.
Chandler Carruth84537952012-03-30 19:44:53 +0000317 if (!Init) {
Richard Smith9c6890a2012-11-01 22:30:59 +0000318 if (!getLangOpts().CPlusPlus)
Chris Lattnere99c1102009-12-05 08:22:11 +0000319 CGM.ErrorUnsupported(D.getInit(), "constant l-value expression");
Matthias Braun44bfe032017-01-10 17:43:01 +0000320 else if (HaveInsertPoint()) {
Eric Christopher31ab1302011-08-23 22:38:00 +0000321 // Since we have a static initializer, this global variable can't
Anders Carlsson20bbbd42010-01-26 04:02:23 +0000322 // be constant.
Chandler Carruth84537952012-03-30 19:44:53 +0000323 GV->setConstant(false);
John McCall68ff0372010-09-08 01:44:27 +0000324
Chandler Carruth84537952012-03-30 19:44:53 +0000325 EmitCXXGuardedInit(D, GV, /*PerformInit*/true);
Anders Carlsson20bbbd42010-01-26 04:02:23 +0000326 }
Chandler Carruth84537952012-03-30 19:44:53 +0000327 return GV;
Chris Lattnere99c1102009-12-05 08:22:11 +0000328 }
John McCall70013b62010-07-15 23:40:35 +0000329
Chris Lattnere99c1102009-12-05 08:22:11 +0000330 // The initializer may differ in type from the global. Rewrite
331 // the global to match the initializer. (We have to do this
332 // because some types, like unions, can't be completely represented
333 // in the LLVM type system.)
Chandler Carruth84537952012-03-30 19:44:53 +0000334 if (GV->getType()->getElementType() != Init->getType()) {
335 llvm::GlobalVariable *OldGV = GV;
336
337 GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(),
338 OldGV->isConstant(),
339 OldGV->getLinkage(), Init, "",
340 /*InsertBefore*/ OldGV,
Hans Wennborgd3b01bc2012-06-23 11:51:46 +0000341 OldGV->getThreadLocalMode(),
Chandler Carruth84537952012-03-30 19:44:53 +0000342 CGM.getContext().getTargetAddressSpace(D.getType()));
343 GV->setVisibility(OldGV->getVisibility());
Rafael Espindola699f5d62018-02-07 22:15:33 +0000344 GV->setDSOLocal(OldGV->isDSOLocal());
Reid Klecknereab97d32015-07-20 20:35:30 +0000345 GV->setComdat(OldGV->getComdat());
Eric Christopher31ab1302011-08-23 22:38:00 +0000346
Chris Lattnere99c1102009-12-05 08:22:11 +0000347 // Steal the name of the old global
Chandler Carruth84537952012-03-30 19:44:53 +0000348 GV->takeName(OldGV);
Eric Christopher31ab1302011-08-23 22:38:00 +0000349
Chris Lattnere99c1102009-12-05 08:22:11 +0000350 // Replace all uses of the old global with the new global
Chandler Carruth84537952012-03-30 19:44:53 +0000351 llvm::Constant *NewPtrForOldDecl =
352 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
353 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
Eric Christopher31ab1302011-08-23 22:38:00 +0000354
Chris Lattnere99c1102009-12-05 08:22:11 +0000355 // Erase the old global, since it is no longer used.
Chandler Carruth84537952012-03-30 19:44:53 +0000356 OldGV->eraseFromParent();
Chris Lattnere99c1102009-12-05 08:22:11 +0000357 }
Eric Christopher31ab1302011-08-23 22:38:00 +0000358
Chandler Carruth84537952012-03-30 19:44:53 +0000359 GV->setConstant(CGM.isTypeConstant(D.getType(), true));
360 GV->setInitializer(Init);
Richard Smith6331c402012-02-13 22:16:19 +0000361
John McCallde0fe072017-08-15 21:42:52 +0000362 emitter.finalize(GV);
363
Matthias Braun44bfe032017-01-10 17:43:01 +0000364 if (hasNontrivialDestruction(D.getType()) && HaveInsertPoint()) {
Richard Smith6331c402012-02-13 22:16:19 +0000365 // We have a constant initializer, but a nontrivial destructor. We still
366 // need to perform a guarded "initialization" in order to register the
Richard Smithe070fd22012-02-17 06:48:11 +0000367 // destructor.
Chandler Carruth84537952012-03-30 19:44:53 +0000368 EmitCXXGuardedInit(D, GV, /*PerformInit*/false);
Richard Smith6331c402012-02-13 22:16:19 +0000369 }
370
Chandler Carruth84537952012-03-30 19:44:53 +0000371 return GV;
Chris Lattnere99c1102009-12-05 08:22:11 +0000372}
373
John McCall1c9c3fd2010-10-15 04:57:14 +0000374void CodeGenFunction::EmitStaticVarDecl(const VarDecl &D,
Anders Carlssoncee2d2f2010-02-07 02:03:08 +0000375 llvm::GlobalValue::LinkageTypes Linkage) {
John McCallb88a5662012-03-30 21:00:39 +0000376 // Check to see if we already have a global variable for this
377 // declaration. This can happen when double-emitting function
378 // bodies, e.g. with complete and base constructors.
Reid Kleckner453e0562014-10-08 01:07:54 +0000379 llvm::Constant *addr = CGM.getOrCreateStaticVarDecl(D, Linkage);
John McCall7f416cc2015-09-08 08:05:57 +0000380 CharUnits alignment = getContext().getDeclAlign(&D);
Daniel Dunbara374e602009-02-25 19:45:19 +0000381
Daniel Dunbar1cdbc542009-02-25 20:08:33 +0000382 // Store into LocalDeclMap before generating initializer to handle
383 // circular references.
John McCall7f416cc2015-09-08 08:05:57 +0000384 setAddrOfLocalVar(&D, Address(addr, alignment));
Daniel Dunbar1cdbc542009-02-25 20:08:33 +0000385
John McCall4a39ab82010-05-04 20:45:42 +0000386 // We can't have a VLA here, but we can have a pointer to a VLA,
387 // even though that doesn't really make any sense.
Eli Friedmanbc633be2009-04-20 03:54:15 +0000388 // Make sure to evaluate VLA bounds now so that we have them for later.
389 if (D.getType()->isVariablyModifiedType())
John McCall23c29fe2011-06-24 21:55:10 +0000390 EmitVariablyModifiedType(D.getType());
Eric Christopher31ab1302011-08-23 22:38:00 +0000391
John McCallb88a5662012-03-30 21:00:39 +0000392 // Save the type in case adding the initializer forces a type change.
393 llvm::Type *expectedType = addr->getType();
Eli Friedmanbc633be2009-04-20 03:54:15 +0000394
Eli Benderskycb399432014-03-24 22:05:38 +0000395 llvm::GlobalVariable *var =
396 cast<llvm::GlobalVariable>(addr->stripPointerCasts());
Artem Belevich4d430ba2016-05-09 22:09:56 +0000397
398 // CUDA's local and local static __shared__ variables should not
399 // have any non-empty initializers. This is ensured by Sema.
400 // Whatever initializer such variable may have when it gets here is
401 // a no-op and should not be emitted.
402 bool isCudaSharedVar = getLangOpts().CUDA && getLangOpts().CUDAIsDevice &&
403 D.hasAttr<CUDASharedAttr>();
Chris Lattnere99c1102009-12-05 08:22:11 +0000404 // If this value has an initializer, emit it.
Artem Belevich4d430ba2016-05-09 22:09:56 +0000405 if (D.getInit() && !isCudaSharedVar)
John McCallb88a5662012-03-30 21:00:39 +0000406 var = AddInitializerToStaticVarDecl(D, var);
Nate Begemanfaae0812008-04-19 04:17:09 +0000407
John McCall7f416cc2015-09-08 08:05:57 +0000408 var->setAlignment(alignment.getQuantity());
Chris Lattner4d941092010-03-10 23:59:59 +0000409
Julien Lerouge5a6b6982011-09-09 22:41:49 +0000410 if (D.hasAttr<AnnotateAttr>())
John McCallb88a5662012-03-30 21:00:39 +0000411 CGM.AddGlobalAnnotations(&D, var);
Nate Begemanfaae0812008-04-19 04:17:09 +0000412
Javed Absar2a67c9e2017-06-05 10:11:57 +0000413 if (auto *SA = D.getAttr<PragmaClangBSSSectionAttr>())
414 var->addAttribute("bss-section", SA->getName());
415 if (auto *SA = D.getAttr<PragmaClangDataSectionAttr>())
416 var->addAttribute("data-section", SA->getName());
417 if (auto *SA = D.getAttr<PragmaClangRodataSectionAttr>())
418 var->addAttribute("rodata-section", SA->getName());
419
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000420 if (const SectionAttr *SA = D.getAttr<SectionAttr>())
John McCallb88a5662012-03-30 21:00:39 +0000421 var->setSection(SA->getName());
Mike Stump11289f42009-09-09 15:08:12 +0000422
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +0000423 if (D.hasAttr<UsedAttr>())
Rafael Espindola060062a2014-03-06 22:15:10 +0000424 CGM.addUsedGlobal(var);
Daniel Dunbar128a1382009-02-13 22:08:43 +0000425
Chandler Carruth84537952012-03-30 19:44:53 +0000426 // We may have to cast the constant because of the initializer
427 // mismatch above.
428 //
429 // FIXME: It is really dangerous to store this in the map; if anyone
430 // RAUW's the GV uses of this constant will be invalid.
Eli Benderskycb399432014-03-24 22:05:38 +0000431 llvm::Constant *castedAddr =
432 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(var, expectedType);
John McCall7f416cc2015-09-08 08:05:57 +0000433 if (var != castedAddr)
434 LocalDeclMap.find(&D)->second = Address(castedAddr, alignment);
John McCallb88a5662012-03-30 21:00:39 +0000435 CGM.setStaticLocalDeclAddress(&D, castedAddr);
Sanjiv Gupta158143a2008-06-05 08:59:10 +0000436
Alexey Samsonov4b8de112014-08-01 21:35:28 +0000437 CGM.getSanitizerMetadata()->reportGlobalToASan(var, D);
Alexey Samsonov4f319cc2014-07-02 16:54:41 +0000438
Sanjiv Gupta158143a2008-06-05 08:59:10 +0000439 // Emit global variable debug descriptor for static vars.
Anders Carlsson63784f42009-02-13 08:11:52 +0000440 CGDebugInfo *DI = getDebugInfo();
Alexey Samsonov74a38682012-05-04 07:39:27 +0000441 if (DI &&
Benjamin Kramer8c305922016-02-02 11:06:51 +0000442 CGM.getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo) {
Daniel Dunbarb9fd9022008-10-17 16:15:48 +0000443 DI->setLocation(D.getLocation());
John McCallb88a5662012-03-30 21:00:39 +0000444 DI->EmitGlobalVariable(var, &D);
Sanjiv Gupta158143a2008-06-05 08:59:10 +0000445 }
Anders Carlssonf94cd1f2007-10-17 00:52:43 +0000446}
Mike Stump11289f42009-09-09 15:08:12 +0000447
John McCall2b7fc382010-07-13 20:32:21 +0000448namespace {
David Blaikie7e70d682015-08-18 22:40:54 +0000449 struct DestroyObject final : EHScopeStack::Cleanup {
John McCall7f416cc2015-09-08 08:05:57 +0000450 DestroyObject(Address addr, QualType type,
John McCall178360e2011-07-11 08:38:19 +0000451 CodeGenFunction::Destroyer *destroyer,
452 bool useEHCleanupForArray)
Peter Collingbourne1425b452012-01-26 03:33:36 +0000453 : addr(addr), type(type), destroyer(destroyer),
John McCall178360e2011-07-11 08:38:19 +0000454 useEHCleanupForArray(useEHCleanupForArray) {}
John McCall2b7fc382010-07-13 20:32:21 +0000455
John McCall7f416cc2015-09-08 08:05:57 +0000456 Address addr;
John McCall82fe67b2011-07-09 01:37:26 +0000457 QualType type;
Peter Collingbourne1425b452012-01-26 03:33:36 +0000458 CodeGenFunction::Destroyer *destroyer;
John McCall178360e2011-07-11 08:38:19 +0000459 bool useEHCleanupForArray;
John McCall2b7fc382010-07-13 20:32:21 +0000460
Craig Topper4f12f102014-03-12 06:41:41 +0000461 void Emit(CodeGenFunction &CGF, Flags flags) override {
John McCall178360e2011-07-11 08:38:19 +0000462 // Don't use an EH cleanup recursively from an EH cleanup.
John McCall30317fd2011-07-12 20:27:29 +0000463 bool useEHCleanupForArray =
464 flags.isForNormalCleanup() && this->useEHCleanupForArray;
John McCall178360e2011-07-11 08:38:19 +0000465
466 CGF.emitDestroy(addr, type, destroyer, useEHCleanupForArray);
John McCall2b7fc382010-07-13 20:32:21 +0000467 }
468 };
469
David Blaikie7e70d682015-08-18 22:40:54 +0000470 struct DestroyNRVOVariable final : EHScopeStack::Cleanup {
John McCall7f416cc2015-09-08 08:05:57 +0000471 DestroyNRVOVariable(Address addr,
John McCall82fe67b2011-07-09 01:37:26 +0000472 const CXXDestructorDecl *Dtor,
473 llvm::Value *NRVOFlag)
474 : Dtor(Dtor), NRVOFlag(NRVOFlag), Loc(addr) {}
John McCall2b7fc382010-07-13 20:32:21 +0000475
476 const CXXDestructorDecl *Dtor;
477 llvm::Value *NRVOFlag;
John McCall7f416cc2015-09-08 08:05:57 +0000478 Address Loc;
John McCall2b7fc382010-07-13 20:32:21 +0000479
Craig Topper4f12f102014-03-12 06:41:41 +0000480 void Emit(CodeGenFunction &CGF, Flags flags) override {
John McCall2b7fc382010-07-13 20:32:21 +0000481 // Along the exceptions path we always execute the dtor.
John McCall30317fd2011-07-12 20:27:29 +0000482 bool NRVO = flags.isForNormalCleanup() && NRVOFlag;
John McCall2b7fc382010-07-13 20:32:21 +0000483
Craig Topper8a13c412014-05-21 05:09:00 +0000484 llvm::BasicBlock *SkipDtorBB = nullptr;
John McCall2b7fc382010-07-13 20:32:21 +0000485 if (NRVO) {
486 // If we exited via NRVO, we skip the destructor call.
487 llvm::BasicBlock *RunDtorBB = CGF.createBasicBlock("nrvo.unused");
488 SkipDtorBB = CGF.createBasicBlock("nrvo.skipdtor");
John McCall7f416cc2015-09-08 08:05:57 +0000489 llvm::Value *DidNRVO =
490 CGF.Builder.CreateFlagLoad(NRVOFlag, "nrvo.val");
John McCall2b7fc382010-07-13 20:32:21 +0000491 CGF.Builder.CreateCondBr(DidNRVO, SkipDtorBB, RunDtorBB);
492 CGF.EmitBlock(RunDtorBB);
493 }
Eric Christopher31ab1302011-08-23 22:38:00 +0000494
John McCall2b7fc382010-07-13 20:32:21 +0000495 CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete,
Douglas Gregor61535002013-01-31 05:50:40 +0000496 /*ForVirtualBase=*/false,
497 /*Delegating=*/false,
498 Loc);
John McCall2b7fc382010-07-13 20:32:21 +0000499
500 if (NRVO) CGF.EmitBlock(SkipDtorBB);
501 }
502 };
John McCall2b7fc382010-07-13 20:32:21 +0000503
David Blaikie7e70d682015-08-18 22:40:54 +0000504 struct CallStackRestore final : EHScopeStack::Cleanup {
John McCall7f416cc2015-09-08 08:05:57 +0000505 Address Stack;
506 CallStackRestore(Address Stack) : Stack(Stack) {}
Craig Topper4f12f102014-03-12 06:41:41 +0000507 void Emit(CodeGenFunction &CGF, Flags flags) override {
Benjamin Kramer76399eb2011-09-27 21:06:10 +0000508 llvm::Value *V = CGF.Builder.CreateLoad(Stack);
John McCalla464ff92010-07-21 06:13:08 +0000509 llvm::Value *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore);
510 CGF.Builder.CreateCall(F, V);
511 }
512 };
513
David Blaikie7e70d682015-08-18 22:40:54 +0000514 struct ExtendGCLifetime final : EHScopeStack::Cleanup {
John McCall1bd25562011-06-24 23:21:27 +0000515 const VarDecl &Var;
516 ExtendGCLifetime(const VarDecl *var) : Var(*var) {}
517
Craig Topper4f12f102014-03-12 06:41:41 +0000518 void Emit(CodeGenFunction &CGF, Flags flags) override {
John McCall1bd25562011-06-24 23:21:27 +0000519 // Compute the address of the local variable, in case it's a
520 // byref or something.
John McCall113bee02012-03-10 09:33:50 +0000521 DeclRefExpr DRE(const_cast<VarDecl*>(&Var), false,
522 Var.getType(), VK_LValue, SourceLocation());
Nick Lewycky2d84e842013-10-02 02:29:49 +0000523 llvm::Value *value = CGF.EmitLoadOfScalar(CGF.EmitDeclRefLValue(&DRE),
524 SourceLocation());
John McCall1bd25562011-06-24 23:21:27 +0000525 CGF.EmitExtendGCLifetime(value);
526 }
527 };
528
David Blaikie7e70d682015-08-18 22:40:54 +0000529 struct CallCleanupFunction final : EHScopeStack::Cleanup {
John McCalla464ff92010-07-21 06:13:08 +0000530 llvm::Constant *CleanupFn;
531 const CGFunctionInfo &FnInfo;
John McCalla464ff92010-07-21 06:13:08 +0000532 const VarDecl &Var;
Eric Christopher31ab1302011-08-23 22:38:00 +0000533
John McCalla464ff92010-07-21 06:13:08 +0000534 CallCleanupFunction(llvm::Constant *CleanupFn, const CGFunctionInfo *Info,
John McCallc533cb72011-02-22 06:44:22 +0000535 const VarDecl *Var)
536 : CleanupFn(CleanupFn), FnInfo(*Info), Var(*Var) {}
John McCalla464ff92010-07-21 06:13:08 +0000537
Craig Topper4f12f102014-03-12 06:41:41 +0000538 void Emit(CodeGenFunction &CGF, Flags flags) override {
John McCall113bee02012-03-10 09:33:50 +0000539 DeclRefExpr DRE(const_cast<VarDecl*>(&Var), false,
540 Var.getType(), VK_LValue, SourceLocation());
John McCallc533cb72011-02-22 06:44:22 +0000541 // Compute the address of the local variable, in case it's a byref
542 // or something.
John McCall7f416cc2015-09-08 08:05:57 +0000543 llvm::Value *Addr = CGF.EmitDeclRefLValue(&DRE).getPointer();
John McCallc533cb72011-02-22 06:44:22 +0000544
John McCalla464ff92010-07-21 06:13:08 +0000545 // In some cases, the type of the function argument will be different from
546 // the type of the pointer. An example of this is
547 // void f(void* arg);
548 // __attribute__((cleanup(f))) void *g;
549 //
550 // To fix this we insert a bitcast here.
551 QualType ArgTy = FnInfo.arg_begin()->type;
552 llvm::Value *Arg =
553 CGF.Builder.CreateBitCast(Addr, CGF.ConvertType(ArgTy));
554
555 CallArgList Args;
Eli Friedman43dca6a2011-05-02 17:57:46 +0000556 Args.add(RValue::get(Arg),
557 CGF.getContext().getPointerType(Var.getType()));
John McCallb92ab1a2016-10-26 23:46:34 +0000558 auto Callee = CGCallee::forDirect(CleanupFn);
559 CGF.EmitCall(FnInfo, Callee, ReturnValueSlot(), Args);
John McCalla464ff92010-07-21 06:13:08 +0000560 }
561 };
Eugene Zelenko0a4f3f42016-02-10 19:11:58 +0000562} // end anonymous namespace
John McCalla464ff92010-07-21 06:13:08 +0000563
John McCall31168b02011-06-15 23:02:42 +0000564/// EmitAutoVarWithLifetime - Does the setup required for an automatic
565/// variable with lifetime.
566static void EmitAutoVarWithLifetime(CodeGenFunction &CGF, const VarDecl &var,
John McCall7f416cc2015-09-08 08:05:57 +0000567 Address addr,
John McCall31168b02011-06-15 23:02:42 +0000568 Qualifiers::ObjCLifetime lifetime) {
569 switch (lifetime) {
570 case Qualifiers::OCL_None:
571 llvm_unreachable("present but none");
572
573 case Qualifiers::OCL_ExplicitNone:
574 // nothing to do
575 break;
576
577 case Qualifiers::OCL_Strong: {
Peter Collingbourne1425b452012-01-26 03:33:36 +0000578 CodeGenFunction::Destroyer *destroyer =
John McCall4bd0fb12011-07-12 16:41:08 +0000579 (var.hasAttr<ObjCPreciseLifetimeAttr>()
580 ? CodeGenFunction::destroyARCStrongPrecise
581 : CodeGenFunction::destroyARCStrongImprecise);
582
583 CleanupKind cleanupKind = CGF.getARCCleanupKind();
584 CGF.pushDestroy(cleanupKind, addr, var.getType(), destroyer,
585 cleanupKind & EHCleanup);
John McCall31168b02011-06-15 23:02:42 +0000586 break;
587 }
588 case Qualifiers::OCL_Autoreleasing:
589 // nothing to do
590 break;
Eric Christopher31ab1302011-08-23 22:38:00 +0000591
John McCall31168b02011-06-15 23:02:42 +0000592 case Qualifiers::OCL_Weak:
593 // __weak objects always get EH cleanups; otherwise, exceptions
594 // could cause really nasty crashes instead of mere leaks.
John McCall4bd0fb12011-07-12 16:41:08 +0000595 CGF.pushDestroy(NormalAndEHCleanup, addr, var.getType(),
596 CodeGenFunction::destroyARCWeak,
597 /*useEHCleanup*/ true);
John McCall31168b02011-06-15 23:02:42 +0000598 break;
599 }
600}
601
602static bool isAccessedBy(const VarDecl &var, const Stmt *s) {
603 if (const Expr *e = dyn_cast<Expr>(s)) {
604 // Skip the most common kinds of expressions that make
605 // hierarchy-walking expensive.
606 s = e = e->IgnoreParenCasts();
607
608 if (const DeclRefExpr *ref = dyn_cast<DeclRefExpr>(e))
609 return (ref->getDecl() == &var);
Fariborz Jahaniana36cbeb2012-06-19 20:53:26 +0000610 if (const BlockExpr *be = dyn_cast<BlockExpr>(e)) {
611 const BlockDecl *block = be->getBlockDecl();
Aaron Ballman9371dd22014-03-14 18:34:04 +0000612 for (const auto &I : block->captures()) {
613 if (I.getVariable() == &var)
Fariborz Jahaniana36cbeb2012-06-19 20:53:26 +0000614 return true;
615 }
616 }
John McCall31168b02011-06-15 23:02:42 +0000617 }
618
Benjamin Kramer642f1732015-07-02 21:03:14 +0000619 for (const Stmt *SubStmt : s->children())
620 // SubStmt might be null; as in missing decl or conditional of an if-stmt.
621 if (SubStmt && isAccessedBy(var, SubStmt))
John McCall31168b02011-06-15 23:02:42 +0000622 return true;
623
624 return false;
625}
626
627static bool isAccessedBy(const ValueDecl *decl, const Expr *e) {
628 if (!decl) return false;
629 if (!isa<VarDecl>(decl)) return false;
630 const VarDecl *var = cast<VarDecl>(decl);
631 return isAccessedBy(*var, e);
632}
633
John McCallf8a9b662015-10-21 18:06:31 +0000634static bool tryEmitARCCopyWeakInit(CodeGenFunction &CGF,
635 const LValue &destLV, const Expr *init) {
John McCall0204e342015-11-16 22:11:41 +0000636 bool needsCast = false;
637
John McCallf8a9b662015-10-21 18:06:31 +0000638 while (auto castExpr = dyn_cast<CastExpr>(init->IgnoreParens())) {
639 switch (castExpr->getCastKind()) {
640 // Look through casts that don't require representation changes.
641 case CK_NoOp:
642 case CK_BitCast:
643 case CK_BlockPointerToObjCPointerCast:
John McCall0204e342015-11-16 22:11:41 +0000644 needsCast = true;
John McCallf8a9b662015-10-21 18:06:31 +0000645 break;
646
647 // If we find an l-value to r-value cast from a __weak variable,
648 // emit this operation as a copy or move.
649 case CK_LValueToRValue: {
650 const Expr *srcExpr = castExpr->getSubExpr();
651 if (srcExpr->getType().getObjCLifetime() != Qualifiers::OCL_Weak)
652 return false;
653
654 // Emit the source l-value.
655 LValue srcLV = CGF.EmitLValue(srcExpr);
656
John McCall0204e342015-11-16 22:11:41 +0000657 // Handle a formal type change to avoid asserting.
658 auto srcAddr = srcLV.getAddress();
659 if (needsCast) {
660 srcAddr = CGF.Builder.CreateElementBitCast(srcAddr,
661 destLV.getAddress().getElementType());
662 }
663
John McCallf8a9b662015-10-21 18:06:31 +0000664 // If it was an l-value, use objc_copyWeak.
665 if (srcExpr->getValueKind() == VK_LValue) {
John McCall0204e342015-11-16 22:11:41 +0000666 CGF.EmitARCCopyWeak(destLV.getAddress(), srcAddr);
John McCallf8a9b662015-10-21 18:06:31 +0000667 } else {
668 assert(srcExpr->getValueKind() == VK_XValue);
John McCall0204e342015-11-16 22:11:41 +0000669 CGF.EmitARCMoveWeak(destLV.getAddress(), srcAddr);
John McCallf8a9b662015-10-21 18:06:31 +0000670 }
671 return true;
672 }
673
674 // Stop at anything else.
675 default:
676 return false;
677 }
678
679 init = castExpr->getSubExpr();
John McCallf8a9b662015-10-21 18:06:31 +0000680 }
681 return false;
682}
683
John McCall1553b192011-06-16 04:16:24 +0000684static void drillIntoBlockVariable(CodeGenFunction &CGF,
685 LValue &lvalue,
686 const VarDecl *var) {
John McCall7f416cc2015-09-08 08:05:57 +0000687 lvalue.setAddress(CGF.emitBlockByrefAddress(lvalue.getAddress(), var));
John McCall1553b192011-06-16 04:16:24 +0000688}
689
Vedant Kumar42c17ec2017-03-14 01:56:34 +0000690void CodeGenFunction::EmitNullabilityCheck(LValue LHS, llvm::Value *RHS,
691 SourceLocation Loc) {
692 if (!SanOpts.has(SanitizerKind::NullabilityAssign))
693 return;
694
695 auto Nullability = LHS.getType()->getNullability(getContext());
696 if (!Nullability || *Nullability != NullabilityKind::NonNull)
697 return;
698
699 // Check if the right hand side of the assignment is nonnull, if the left
700 // hand side must be nonnull.
701 SanitizerScope SanScope(this);
702 llvm::Value *IsNotNull = Builder.CreateIsNotNull(RHS);
Vedant Kumar42c17ec2017-03-14 01:56:34 +0000703 llvm::Constant *StaticData[] = {
704 EmitCheckSourceLocation(Loc), EmitCheckTypeDescriptor(LHS.getType()),
Simon Pilgrim2df19982017-03-14 21:43:52 +0000705 llvm::ConstantInt::get(Int8Ty, 0), // The LogAlignment info is unused.
Vedant Kumar2b9f48a2017-03-14 16:48:29 +0000706 llvm::ConstantInt::get(Int8Ty, TCK_NonnullAssign)};
Vedant Kumar42c17ec2017-03-14 01:56:34 +0000707 EmitCheck({{IsNotNull, SanitizerKind::NullabilityAssign}},
708 SanitizerHandler::TypeMismatch, StaticData, RHS);
709}
710
David Blaikie73ca5692014-12-09 00:32:22 +0000711void CodeGenFunction::EmitScalarInit(const Expr *init, const ValueDecl *D,
David Blaikie66e41972015-01-14 07:38:27 +0000712 LValue lvalue, bool capturedByInit) {
John McCall1553b192011-06-16 04:16:24 +0000713 Qualifiers::ObjCLifetime lifetime = lvalue.getObjCLifetime();
John McCall31168b02011-06-15 23:02:42 +0000714 if (!lifetime) {
715 llvm::Value *value = EmitScalarExpr(init);
John McCall1553b192011-06-16 04:16:24 +0000716 if (capturedByInit)
717 drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
Vedant Kumar42c17ec2017-03-14 01:56:34 +0000718 EmitNullabilityCheck(lvalue, value, init->getExprLoc());
David Blaikie66e41972015-01-14 07:38:27 +0000719 EmitStoreThroughLValue(RValue::get(value), lvalue, true);
John McCall31168b02011-06-15 23:02:42 +0000720 return;
721 }
Vitaly Buka9d4eb6f2016-06-02 00:24:20 +0000722
Fariborz Jahaniana5a469e2014-03-14 15:40:54 +0000723 if (const CXXDefaultInitExpr *DIE = dyn_cast<CXXDefaultInitExpr>(init))
724 init = DIE->getExpr();
Vitaly Buka9d4eb6f2016-06-02 00:24:20 +0000725
John McCall31168b02011-06-15 23:02:42 +0000726 // If we're emitting a value with lifetime, we have to do the
727 // initialization *before* we leave the cleanup scopes.
John McCall08ef4662011-11-10 08:15:53 +0000728 if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(init)) {
729 enterFullExpression(ewc);
John McCall31168b02011-06-15 23:02:42 +0000730 init = ewc->getSubExpr();
John McCall08ef4662011-11-10 08:15:53 +0000731 }
732 CodeGenFunction::RunCleanupsScope Scope(*this);
John McCall31168b02011-06-15 23:02:42 +0000733
734 // We have to maintain the illusion that the variable is
735 // zero-initialized. If the variable might be accessed in its
736 // initializer, zero-initialize before running the initializer, then
737 // actually perform the initialization with an assign.
738 bool accessedByInit = false;
739 if (lifetime != Qualifiers::OCL_ExplicitNone)
John McCallb726a552011-07-28 07:23:35 +0000740 accessedByInit = (capturedByInit || isAccessedBy(D, init));
John McCall31168b02011-06-15 23:02:42 +0000741 if (accessedByInit) {
John McCall1553b192011-06-16 04:16:24 +0000742 LValue tempLV = lvalue;
John McCall31168b02011-06-15 23:02:42 +0000743 // Drill down to the __block object if necessary.
John McCall31168b02011-06-15 23:02:42 +0000744 if (capturedByInit) {
745 // We can use a simple GEP for this because it can't have been
746 // moved yet.
John McCall7f416cc2015-09-08 08:05:57 +0000747 tempLV.setAddress(emitBlockByrefAddress(tempLV.getAddress(),
748 cast<VarDecl>(D),
749 /*follow*/ false));
John McCall31168b02011-06-15 23:02:42 +0000750 }
751
John McCall7f416cc2015-09-08 08:05:57 +0000752 auto ty = cast<llvm::PointerType>(tempLV.getAddress().getElementType());
Yaxun Liu402804b2016-12-15 08:09:08 +0000753 llvm::Value *zero = CGM.getNullPointer(ty, tempLV.getType());
Eric Christopher31ab1302011-08-23 22:38:00 +0000754
John McCall31168b02011-06-15 23:02:42 +0000755 // If __weak, we want to use a barrier under certain conditions.
756 if (lifetime == Qualifiers::OCL_Weak)
John McCall1553b192011-06-16 04:16:24 +0000757 EmitARCInitWeak(tempLV.getAddress(), zero);
John McCall31168b02011-06-15 23:02:42 +0000758
759 // Otherwise just do a simple store.
760 else
David Chisnallfa35df62012-01-16 17:27:18 +0000761 EmitStoreOfScalar(zero, tempLV, /* isInitialization */ true);
John McCall31168b02011-06-15 23:02:42 +0000762 }
763
764 // Emit the initializer.
Craig Topper8a13c412014-05-21 05:09:00 +0000765 llvm::Value *value = nullptr;
John McCall31168b02011-06-15 23:02:42 +0000766
767 switch (lifetime) {
768 case Qualifiers::OCL_None:
769 llvm_unreachable("present but none");
770
771 case Qualifiers::OCL_ExplicitNone:
John McCalle399e5b2016-01-27 18:32:30 +0000772 value = EmitARCUnsafeUnretainedScalarExpr(init);
John McCall31168b02011-06-15 23:02:42 +0000773 break;
774
775 case Qualifiers::OCL_Strong: {
776 value = EmitARCRetainScalarExpr(init);
777 break;
778 }
779
780 case Qualifiers::OCL_Weak: {
John McCallf8a9b662015-10-21 18:06:31 +0000781 // If it's not accessed by the initializer, try to emit the
782 // initialization with a copy or move.
783 if (!accessedByInit && tryEmitARCCopyWeakInit(*this, lvalue, init)) {
784 return;
785 }
786
John McCall31168b02011-06-15 23:02:42 +0000787 // No way to optimize a producing initializer into this. It's not
788 // worth optimizing for, because the value will immediately
789 // disappear in the common case.
790 value = EmitScalarExpr(init);
791
John McCall1553b192011-06-16 04:16:24 +0000792 if (capturedByInit) drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
John McCall31168b02011-06-15 23:02:42 +0000793 if (accessedByInit)
John McCall1553b192011-06-16 04:16:24 +0000794 EmitARCStoreWeak(lvalue.getAddress(), value, /*ignored*/ true);
John McCall31168b02011-06-15 23:02:42 +0000795 else
John McCall1553b192011-06-16 04:16:24 +0000796 EmitARCInitWeak(lvalue.getAddress(), value);
John McCall31168b02011-06-15 23:02:42 +0000797 return;
798 }
799
800 case Qualifiers::OCL_Autoreleasing:
801 value = EmitARCRetainAutoreleaseScalarExpr(init);
802 break;
803 }
804
John McCall1553b192011-06-16 04:16:24 +0000805 if (capturedByInit) drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
John McCall31168b02011-06-15 23:02:42 +0000806
Vedant Kumar42c17ec2017-03-14 01:56:34 +0000807 EmitNullabilityCheck(lvalue, value, init->getExprLoc());
808
John McCall31168b02011-06-15 23:02:42 +0000809 // If the variable might have been accessed by its initializer, we
810 // might have to initialize with a barrier. We have to do this for
811 // both __weak and __strong, but __weak got filtered out above.
812 if (accessedByInit && lifetime == Qualifiers::OCL_Strong) {
Nick Lewycky2d84e842013-10-02 02:29:49 +0000813 llvm::Value *oldValue = EmitLoadOfScalar(lvalue, init->getExprLoc());
David Chisnallfa35df62012-01-16 17:27:18 +0000814 EmitStoreOfScalar(value, lvalue, /* isInitialization */ true);
John McCallcdda29c2013-03-13 03:10:54 +0000815 EmitARCRelease(oldValue, ARCImpreciseLifetime);
John McCall31168b02011-06-15 23:02:42 +0000816 return;
817 }
818
David Chisnallfa35df62012-01-16 17:27:18 +0000819 EmitStoreOfScalar(value, lvalue, /* isInitialization */ true);
John McCall31168b02011-06-15 23:02:42 +0000820}
Chris Lattnerb85025f2010-12-01 02:05:19 +0000821
822/// canEmitInitWithFewStoresAfterMemset - Decide whether we can emit the
823/// non-zero parts of the specified initializer with equal or fewer than
824/// NumStores scalar stores.
825static bool canEmitInitWithFewStoresAfterMemset(llvm::Constant *Init,
826 unsigned &NumStores) {
Chris Lattnere6af8862010-12-02 01:58:41 +0000827 // Zero and Undef never requires any extra stores.
828 if (isa<llvm::ConstantAggregateZero>(Init) ||
829 isa<llvm::ConstantPointerNull>(Init) ||
830 isa<llvm::UndefValue>(Init))
831 return true;
832 if (isa<llvm::ConstantInt>(Init) || isa<llvm::ConstantFP>(Init) ||
833 isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
834 isa<llvm::ConstantExpr>(Init))
835 return Init->isNullValue() || NumStores--;
836
837 // See if we can emit each element.
838 if (isa<llvm::ConstantArray>(Init) || isa<llvm::ConstantStruct>(Init)) {
839 for (unsigned i = 0, e = Init->getNumOperands(); i != e; ++i) {
840 llvm::Constant *Elt = cast<llvm::Constant>(Init->getOperand(i));
841 if (!canEmitInitWithFewStoresAfterMemset(Elt, NumStores))
842 return false;
843 }
844 return true;
845 }
Vitaly Buka9d4eb6f2016-06-02 00:24:20 +0000846
Chris Lattner236b3572012-01-31 04:36:19 +0000847 if (llvm::ConstantDataSequential *CDS =
848 dyn_cast<llvm::ConstantDataSequential>(Init)) {
849 for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
850 llvm::Constant *Elt = CDS->getElementAsConstant(i);
851 if (!canEmitInitWithFewStoresAfterMemset(Elt, NumStores))
852 return false;
853 }
854 return true;
855 }
Eric Christopher31ab1302011-08-23 22:38:00 +0000856
Chris Lattnerb85025f2010-12-01 02:05:19 +0000857 // Anything else is hard and scary.
858 return false;
859}
860
861/// emitStoresForInitAfterMemset - For inits that
862/// canEmitInitWithFewStoresAfterMemset returned true for, emit the scalar
863/// stores that would be required.
864static void emitStoresForInitAfterMemset(llvm::Constant *Init, llvm::Value *Loc,
John McCallc533cb72011-02-22 06:44:22 +0000865 bool isVolatile, CGBuilderTy &Builder) {
Benjamin Kramer29f9a002012-08-27 22:07:02 +0000866 assert(!Init->isNullValue() && !isa<llvm::UndefValue>(Init) &&
867 "called emitStoresForInitAfterMemset for zero or undef value.");
Eric Christopher31ab1302011-08-23 22:38:00 +0000868
Chris Lattnere6af8862010-12-02 01:58:41 +0000869 if (isa<llvm::ConstantInt>(Init) || isa<llvm::ConstantFP>(Init) ||
870 isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
871 isa<llvm::ConstantExpr>(Init)) {
John McCall7f416cc2015-09-08 08:05:57 +0000872 Builder.CreateDefaultAlignedStore(Init, Loc, isVolatile);
Chris Lattner236b3572012-01-31 04:36:19 +0000873 return;
874 }
Vitaly Buka9d4eb6f2016-06-02 00:24:20 +0000875
876 if (llvm::ConstantDataSequential *CDS =
877 dyn_cast<llvm::ConstantDataSequential>(Init)) {
Chris Lattner236b3572012-01-31 04:36:19 +0000878 for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
879 llvm::Constant *Elt = CDS->getElementAsConstant(i);
Benjamin Kramer46cbe772012-08-27 21:35:58 +0000880
881 // If necessary, get a pointer to the element and emit it.
882 if (!Elt->isNullValue() && !isa<llvm::UndefValue>(Elt))
David Blaikie17ea2662015-04-04 21:07:17 +0000883 emitStoresForInitAfterMemset(
884 Elt, Builder.CreateConstGEP2_32(Init->getType(), Loc, 0, i),
885 isVolatile, Builder);
Chris Lattner236b3572012-01-31 04:36:19 +0000886 }
Chris Lattnere6af8862010-12-02 01:58:41 +0000887 return;
888 }
Eric Christopher31ab1302011-08-23 22:38:00 +0000889
Chris Lattnere6af8862010-12-02 01:58:41 +0000890 assert((isa<llvm::ConstantStruct>(Init) || isa<llvm::ConstantArray>(Init)) &&
891 "Unknown value type!");
Eric Christopher31ab1302011-08-23 22:38:00 +0000892
Chris Lattnere6af8862010-12-02 01:58:41 +0000893 for (unsigned i = 0, e = Init->getNumOperands(); i != e; ++i) {
894 llvm::Constant *Elt = cast<llvm::Constant>(Init->getOperand(i));
Benjamin Kramer46cbe772012-08-27 21:35:58 +0000895
896 // If necessary, get a pointer to the element and emit it.
897 if (!Elt->isNullValue() && !isa<llvm::UndefValue>(Elt))
David Blaikie17ea2662015-04-04 21:07:17 +0000898 emitStoresForInitAfterMemset(
899 Elt, Builder.CreateConstGEP2_32(Init->getType(), Loc, 0, i),
900 isVolatile, Builder);
Chris Lattnere6af8862010-12-02 01:58:41 +0000901 }
Chris Lattnerb85025f2010-12-01 02:05:19 +0000902}
903
Chris Lattnerb85025f2010-12-01 02:05:19 +0000904/// shouldUseMemSetPlusStoresToInitialize - Decide whether we should use memset
905/// plus some stores to initialize a local variable instead of using a memcpy
906/// from a constant global. It is beneficial to use memset if the global is all
907/// zeros, or mostly zeros and large.
908static bool shouldUseMemSetPlusStoresToInitialize(llvm::Constant *Init,
909 uint64_t GlobalSize) {
910 // If a global is all zeros, always use a memset.
911 if (isa<llvm::ConstantAggregateZero>(Init)) return true;
912
Chris Lattnerb85025f2010-12-01 02:05:19 +0000913 // If a non-zero global is <= 32 bytes, always use a memcpy. If it is large,
914 // do it if it will require 6 or fewer scalar stores.
915 // TODO: Should budget depends on the size? Avoiding a large global warrants
916 // plopping in more stores.
917 unsigned StoreBudget = 6;
918 uint64_t SizeLimit = 32;
Eric Christopher31ab1302011-08-23 22:38:00 +0000919
920 return GlobalSize > SizeLimit &&
Chris Lattnerb85025f2010-12-01 02:05:19 +0000921 canEmitInitWithFewStoresAfterMemset(Init, StoreBudget);
922}
923
Nick Lewycky8a7d90b2010-12-30 20:21:55 +0000924/// EmitAutoVarDecl - Emit code and set up an entry in LocalDeclMap for a
Chris Lattner03df1222007-06-02 04:53:11 +0000925/// variable declaration with auto, register, or no storage class specifier.
Chris Lattnerb781dc792008-05-08 05:58:21 +0000926/// These turn into simple stack objects, or GlobalValues depending on target.
John McCallc533cb72011-02-22 06:44:22 +0000927void CodeGenFunction::EmitAutoVarDecl(const VarDecl &D) {
928 AutoVarEmission emission = EmitAutoVarAlloca(D);
929 EmitAutoVarInit(emission);
930 EmitAutoVarCleanups(emission);
931}
Chris Lattner03df1222007-06-02 04:53:11 +0000932
David Majnemerdc012fa2015-04-22 21:38:15 +0000933/// Emit a lifetime.begin marker if some criteria are satisfied.
934/// \return a pointer to the temporary size Value if a marker was emitted, null
935/// otherwise
936llvm::Value *CodeGenFunction::EmitLifetimeStart(uint64_t Size,
937 llvm::Value *Addr) {
Vitaly Buka1c943322016-10-26 01:59:57 +0000938 if (!ShouldEmitLifetimeMarkers)
Reid Kleckner1ef49212015-04-23 18:07:13 +0000939 return nullptr;
940
David Majnemerdc012fa2015-04-22 21:38:15 +0000941 llvm::Value *SizeV = llvm::ConstantInt::get(Int64Ty, Size);
Yaxun Liu7f7f3232017-04-17 20:03:11 +0000942 Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
Alexey Samsonovd918ff62015-06-12 22:31:32 +0000943 llvm::CallInst *C =
944 Builder.CreateCall(CGM.getLLVMLifetimeStartFn(), {SizeV, Addr});
David Majnemerdc012fa2015-04-22 21:38:15 +0000945 C->setDoesNotThrow();
946 return SizeV;
947}
948
949void CodeGenFunction::EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr) {
Yaxun Liu7f7f3232017-04-17 20:03:11 +0000950 Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
Alexey Samsonovd918ff62015-06-12 22:31:32 +0000951 llvm::CallInst *C =
952 Builder.CreateCall(CGM.getLLVMLifetimeEndFn(), {Size, Addr});
David Majnemerdc012fa2015-04-22 21:38:15 +0000953 C->setDoesNotThrow();
954}
955
Sander de Smalen891af03a2018-02-03 13:55:59 +0000956void CodeGenFunction::EmitAndRegisterVariableArrayDimensions(
957 CGDebugInfo *DI, const VarDecl &D, bool EmitDebugInfo) {
958 // For each dimension stores its QualType and corresponding
959 // size-expression Value.
960 SmallVector<CodeGenFunction::VlaSizePair, 4> Dimensions;
961
962 // Break down the array into individual dimensions.
963 QualType Type1D = D.getType();
964 while (getContext().getAsVariableArrayType(Type1D)) {
965 auto VlaSize = getVLAElements1D(Type1D);
966 if (auto *C = dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))
967 Dimensions.emplace_back(C, Type1D.getUnqualifiedType());
968 else {
Sander de Smalen9084a3b2018-02-13 07:49:34 +0000969 auto SizeExprAddr = CreateDefaultAlignTempAlloca(
970 VlaSize.NumElts->getType(), "__vla_expr");
Sander de Smalen891af03a2018-02-03 13:55:59 +0000971 Builder.CreateStore(VlaSize.NumElts, SizeExprAddr);
972 Dimensions.emplace_back(SizeExprAddr.getPointer(),
973 Type1D.getUnqualifiedType());
974 }
975 Type1D = VlaSize.Type;
976 }
977
978 if (!EmitDebugInfo)
979 return;
980
981 // Register each dimension's size-expression with a DILocalVariable,
982 // so that it can be used by CGDebugInfo when instantiating a DISubrange
983 // to describe this array.
984 for (auto &VlaSize : Dimensions) {
985 llvm::Metadata *MD;
986 if (auto *C = dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))
987 MD = llvm::ConstantAsMetadata::get(C);
988 else {
989 // Create an artificial VarDecl to generate debug info for.
990 IdentifierInfo &NameIdent = getContext().Idents.getOwn(
991 cast<llvm::AllocaInst>(VlaSize.NumElts)->getName());
992 auto VlaExprTy = VlaSize.NumElts->getType()->getPointerElementType();
993 auto QT = getContext().getIntTypeForBitwidth(
994 VlaExprTy->getScalarSizeInBits(), false);
995 auto *ArtificialDecl = VarDecl::Create(
996 getContext(), const_cast<DeclContext *>(D.getDeclContext()),
997 D.getLocation(), D.getLocation(), &NameIdent, QT,
998 getContext().CreateTypeSourceInfo(QT), SC_Auto);
Sander de Smalen9084a3b2018-02-13 07:49:34 +0000999 ArtificialDecl->setImplicit();
Sander de Smalen891af03a2018-02-03 13:55:59 +00001000
1001 MD = DI->EmitDeclareOfAutoVariable(ArtificialDecl, VlaSize.NumElts,
1002 Builder);
1003 }
1004 assert(MD && "No Size expression debug node created");
1005 DI->registerVLASizeExpression(VlaSize.Type, MD);
1006 }
1007}
1008
John McCallc533cb72011-02-22 06:44:22 +00001009/// EmitAutoVarAlloca - Emit the alloca and debug information for a
Alp Tokerf6a24ce2013-12-05 16:25:25 +00001010/// local variable. Does not emit initialization or destruction.
John McCallc533cb72011-02-22 06:44:22 +00001011CodeGenFunction::AutoVarEmission
1012CodeGenFunction::EmitAutoVarAlloca(const VarDecl &D) {
1013 QualType Ty = D.getType();
Yaxun Liub7318e02017-10-13 03:37:48 +00001014 assert(
1015 Ty.getAddressSpace() == LangAS::Default ||
1016 (Ty.getAddressSpace() == LangAS::opencl_private && getLangOpts().OpenCL));
John McCallc533cb72011-02-22 06:44:22 +00001017
1018 AutoVarEmission emission(D);
1019
1020 bool isByRef = D.hasAttr<BlocksAttr>();
1021 emission.IsByRef = isByRef;
1022
1023 CharUnits alignment = getContext().getDeclAlign(&D);
John McCallc533cb72011-02-22 06:44:22 +00001024
John McCall23c29fe2011-06-24 21:55:10 +00001025 // If the type is variably-modified, emit all the VLA sizes for it.
1026 if (Ty->isVariablyModifiedType())
1027 EmitVariablyModifiedType(Ty);
1028
Sander de Smalen891af03a2018-02-03 13:55:59 +00001029 auto *DI = getDebugInfo();
1030 bool EmitDebugInfo = DI && CGM.getCodeGenOpts().getDebugInfo() >=
1031 codegenoptions::LimitedDebugInfo;
1032
John McCall7f416cc2015-09-08 08:05:57 +00001033 Address address = Address::invalid();
Eli Friedmana682d392008-02-15 12:20:59 +00001034 if (Ty->isConstantSizeType()) {
Rafael Espindola609f5d92013-03-26 18:41:47 +00001035 bool NRVO = getLangOpts().ElideConstructors &&
1036 D.isNRVOVariable();
John McCallc533cb72011-02-22 06:44:22 +00001037
Richard Smith2bcde3a2013-06-02 00:09:52 +00001038 // If this value is an array or struct with a statically determinable
1039 // constant initializer, there are optimizations we can do.
Rafael Espindola609f5d92013-03-26 18:41:47 +00001040 //
1041 // TODO: We should constant-evaluate the initializer of any variable,
1042 // as long as it is initialized by a constant expression. Currently,
1043 // isConstantInitializer produces wrong answers for structs with
1044 // reference or bitfield members, and a few other cases, and checking
1045 // for POD-ness protects us from some of these.
Richard Smith2bcde3a2013-06-02 00:09:52 +00001046 if (D.getInit() && (Ty->isArrayType() || Ty->isRecordType()) &&
1047 (D.isConstexpr() ||
1048 ((Ty.isPODType(getContext()) ||
1049 getContext().getBaseElementType(Ty)->isObjCObjectPointerType()) &&
1050 D.getInit()->isConstantInitializer(getContext(), false)))) {
John McCallc533cb72011-02-22 06:44:22 +00001051
Rafael Espindola609f5d92013-03-26 18:41:47 +00001052 // If the variable's a const type, and it's neither an NRVO
1053 // candidate nor a __block variable and has no mutable members,
1054 // emit it as a global instead.
Anastasia Stulovae4a1c382016-11-29 17:01:19 +00001055 // Exception is if a variable is located in non-constant address space
1056 // in OpenCL.
1057 if ((!getLangOpts().OpenCL ||
1058 Ty.getAddressSpace() == LangAS::opencl_constant) &&
1059 (CGM.getCodeGenOpts().MergeAllConstants && !NRVO && !isByRef &&
1060 CGM.isTypeConstant(Ty, true))) {
Rafael Espindola609f5d92013-03-26 18:41:47 +00001061 EmitStaticVarDecl(D, llvm::GlobalValue::InternalLinkage);
John McCallc533cb72011-02-22 06:44:22 +00001062
John McCall7f416cc2015-09-08 08:05:57 +00001063 // Signal this condition to later callbacks.
1064 emission.Addr = Address::invalid();
Rafael Espindola609f5d92013-03-26 18:41:47 +00001065 assert(emission.wasEmittedAsGlobal());
1066 return emission;
Tanya Lattnerf9d41df2009-11-04 01:18:09 +00001067 }
Eric Christopher31ab1302011-08-23 22:38:00 +00001068
Rafael Espindola609f5d92013-03-26 18:41:47 +00001069 // Otherwise, tell the initialization code that we're in this case.
1070 emission.IsConstantAggregate = true;
1071 }
Eric Christopher31ab1302011-08-23 22:38:00 +00001072
Rafael Espindola609f5d92013-03-26 18:41:47 +00001073 // A normal fixed sized variable becomes an alloca in the entry block,
Gheorghe-Teodor Bercead3dcf2f2018-03-14 14:17:45 +00001074 // unless:
1075 // - it's an NRVO variable.
1076 // - we are compiling OpenMP and it's an OpenMP local variable.
Eric Christopher31ab1302011-08-23 22:38:00 +00001077
Gheorghe-Teodor Bercead3dcf2f2018-03-14 14:17:45 +00001078 Address OpenMPLocalAddr =
1079 getLangOpts().OpenMP
1080 ? CGM.getOpenMPRuntime().getAddressOfLocalVariable(*this, &D)
1081 : Address::invalid();
1082 if (getLangOpts().OpenMP && OpenMPLocalAddr.isValid()) {
1083 address = OpenMPLocalAddr;
1084 } else if (NRVO) {
Rafael Espindola609f5d92013-03-26 18:41:47 +00001085 // The named return value optimization: allocate this variable in the
1086 // return slot, so that we can elide the copy when returning this
1087 // variable (C++0x [class.copy]p34).
John McCall7f416cc2015-09-08 08:05:57 +00001088 address = ReturnValue;
Eric Christopher31ab1302011-08-23 22:38:00 +00001089
Rafael Espindola609f5d92013-03-26 18:41:47 +00001090 if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
1091 if (!cast<CXXRecordDecl>(RecordTy->getDecl())->hasTrivialDestructor()) {
1092 // Create a flag that is used to indicate when the NRVO was applied
1093 // to this variable. Set it to zero to indicate that NRVO was not
1094 // applied.
1095 llvm::Value *Zero = Builder.getFalse();
John McCall7f416cc2015-09-08 08:05:57 +00001096 Address NRVOFlag =
1097 CreateTempAlloca(Zero->getType(), CharUnits::One(), "nrvo");
Rafael Espindola609f5d92013-03-26 18:41:47 +00001098 EnsureInsertPoint();
1099 Builder.CreateStore(Zero, NRVOFlag);
Eric Christopher31ab1302011-08-23 22:38:00 +00001100
Rafael Espindola609f5d92013-03-26 18:41:47 +00001101 // Record the NRVO flag for this variable.
John McCall7f416cc2015-09-08 08:05:57 +00001102 NRVOFlags[&D] = NRVOFlag.getPointer();
1103 emission.NRVOFlag = NRVOFlag.getPointer();
Nadav Rotem1da30942013-03-23 06:43:35 +00001104 }
Douglas Gregor290c93e2010-05-15 06:46:45 +00001105 }
Chris Lattnerb781dc792008-05-08 05:58:21 +00001106 } else {
John McCall7f416cc2015-09-08 08:05:57 +00001107 CharUnits allocaAlignment;
1108 llvm::Type *allocaTy;
1109 if (isByRef) {
1110 auto &byrefInfo = getBlockByrefInfo(&D);
1111 allocaTy = byrefInfo.Type;
1112 allocaAlignment = byrefInfo.ByrefAlignment;
1113 } else {
1114 allocaTy = ConvertTypeForMem(Ty);
1115 allocaAlignment = alignment;
1116 }
Rafael Espindola609f5d92013-03-26 18:41:47 +00001117
John McCall999110f2015-09-08 09:18:30 +00001118 // Create the alloca. Note that we set the name separately from
1119 // building the instruction so that it's there even in no-asserts
1120 // builds.
Yaxun Liu84744c12017-06-19 17:03:41 +00001121 address = CreateTempAlloca(allocaTy, allocaAlignment, D.getName());
Rafael Espindola609f5d92013-03-26 18:41:47 +00001122
Reid Kleckner1f88e932015-10-07 21:03:41 +00001123 // Don't emit lifetime markers for MSVC catch parameters. The lifetime of
1124 // the catch parameter starts in the catchpad instruction, and we can't
1125 // insert code in those basic blocks.
1126 bool IsMSCatchParam =
1127 D.isExceptionVariable() && getTarget().getCXXABI().isMicrosoft();
1128
Vitaly Buka64c80b42016-10-26 05:42:30 +00001129 // Emit a lifetime intrinsic if meaningful. There's no point in doing this
1130 // if we don't have a valid insertion point (?).
Reid Kleckner1f88e932015-10-07 21:03:41 +00001131 if (HaveInsertPoint() && !IsMSCatchParam) {
Akira Hatanakafdcd18b2017-01-25 22:55:13 +00001132 // If there's a jump into the lifetime of this variable, its lifetime
1133 // gets broken up into several regions in IR, which requires more work
1134 // to handle correctly. For now, just omit the intrinsics; this is a
1135 // rare case, and it's better to just be conservatively correct.
1136 // PR28267.
1137 //
1138 // We have to do this in all language modes if there's a jump past the
1139 // declaration. We also have to do it in C if there's a jump to an
1140 // earlier point in the current block because non-VLA lifetimes begin as
1141 // soon as the containing block is entered, not when its variables
1142 // actually come into scope; suppressing the lifetime annotations
1143 // completely in this case is unnecessarily pessimistic, but again, this
1144 // is rare.
1145 if (!Bypasses.IsBypassed(&D) &&
1146 !(!getLangOpts().CPlusPlus && hasLabelBeenSeenInCurrentScope())) {
Vitaly Buka64c80b42016-10-26 05:42:30 +00001147 uint64_t size = CGM.getDataLayout().getTypeAllocSize(allocaTy);
1148 emission.SizeForLifetimeMarkers =
1149 EmitLifetimeStart(size, address.getPointer());
1150 }
Arnaud A. de Grandmaisone69ec552014-10-08 14:04:26 +00001151 } else {
Rafael Espindola609f5d92013-03-26 18:41:47 +00001152 assert(!emission.useLifetimeMarkers());
Arnaud A. de Grandmaisone69ec552014-10-08 14:04:26 +00001153 }
Chris Lattnerb781dc792008-05-08 05:58:21 +00001154 }
Chris Lattner03df1222007-06-02 04:53:11 +00001155 } else {
Daniel Dunbarb6adc432009-07-19 06:58:07 +00001156 EnsureInsertPoint();
1157
Anders Carlsson15949b32009-02-09 20:41:50 +00001158 if (!DidCallStackSave) {
Anders Carlsson30032882008-12-12 07:38:43 +00001159 // Save the stack.
John McCall7f416cc2015-09-08 08:05:57 +00001160 Address Stack =
1161 CreateTempAlloca(Int8PtrTy, getPointerAlign(), "saved_stack");
Mike Stump11289f42009-09-09 15:08:12 +00001162
Anders Carlsson30032882008-12-12 07:38:43 +00001163 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::stacksave);
David Blaikie4ba525b2015-07-14 17:27:39 +00001164 llvm::Value *V = Builder.CreateCall(F);
Anders Carlsson30032882008-12-12 07:38:43 +00001165 Builder.CreateStore(V, Stack);
Anders Carlsson15949b32009-02-09 20:41:50 +00001166
1167 DidCallStackSave = true;
Mike Stump11289f42009-09-09 15:08:12 +00001168
John McCalla464ff92010-07-21 06:13:08 +00001169 // Push a cleanup block and restore the stack there.
John McCalle4df6c82011-01-28 08:37:24 +00001170 // FIXME: in general circumstances, this should be an EH cleanup.
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001171 pushStackRestore(NormalCleanup, Stack);
Anders Carlsson30032882008-12-12 07:38:43 +00001172 }
Mike Stump11289f42009-09-09 15:08:12 +00001173
Sander de Smalen891af03a2018-02-03 13:55:59 +00001174 auto VlaSize = getVLASize(Ty);
1175 llvm::Type *llvmTy = ConvertTypeForMem(VlaSize.Type);
Anders Carlsson30032882008-12-12 07:38:43 +00001176
1177 // Allocate memory for the array.
Sander de Smalen891af03a2018-02-03 13:55:59 +00001178 address = CreateTempAlloca(llvmTy, alignment, "vla", VlaSize.NumElts);
1179
1180 // If we have debug info enabled, properly describe the VLA dimensions for
1181 // this type by registering the vla size expression for each of the
1182 // dimensions.
1183 EmitAndRegisterVariableArrayDimensions(DI, D, EmitDebugInfo);
Chris Lattner03df1222007-06-02 04:53:11 +00001184 }
Eli Friedmanf4084702008-12-20 23:11:59 +00001185
John McCall7f416cc2015-09-08 08:05:57 +00001186 setAddrOfLocalVar(&D, address);
1187 emission.Addr = address;
Sanjiv Gupta18de6242008-05-30 10:30:31 +00001188
1189 // Emit debug info for local var declaration.
Sander de Smalen891af03a2018-02-03 13:55:59 +00001190 if (EmitDebugInfo && HaveInsertPoint()) {
1191 DI->setLocation(D.getLocation());
1192 (void)DI->EmitDeclareOfAutoVariable(&D, address.getPointer(), Builder);
1193 }
Sanjiv Gupta18de6242008-05-30 10:30:31 +00001194
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001195 if (D.hasAttr<AnnotateAttr>())
John McCall7f416cc2015-09-08 08:05:57 +00001196 EmitVarAnnotations(&D, address.getPointer());
Julien Lerouge5a6b6982011-09-09 22:41:49 +00001197
Kuba Mracek5e5e4e72017-04-14 16:53:25 +00001198 // Make sure we call @llvm.lifetime.end.
1199 if (emission.useLifetimeMarkers())
1200 EHStack.pushCleanup<CallLifetimeEnd>(NormalEHLifetimeMarker,
1201 emission.getAllocatedAddress(),
1202 emission.getSizeForLifetimeMarkers());
1203
John McCallc533cb72011-02-22 06:44:22 +00001204 return emission;
1205}
1206
1207/// Determines whether the given __block variable is potentially
1208/// captured by the given expression.
1209static bool isCapturedBy(const VarDecl &var, const Expr *e) {
1210 // Skip the most common kinds of expressions that make
1211 // hierarchy-walking expensive.
1212 e = e->IgnoreParenCasts();
1213
1214 if (const BlockExpr *be = dyn_cast<BlockExpr>(e)) {
1215 const BlockDecl *block = be->getBlockDecl();
Aaron Ballman9371dd22014-03-14 18:34:04 +00001216 for (const auto &I : block->captures()) {
1217 if (I.getVariable() == &var)
John McCallc533cb72011-02-22 06:44:22 +00001218 return true;
1219 }
1220
1221 // No need to walk into the subexpressions.
1222 return false;
1223 }
1224
Fariborz Jahanian797f1e22011-08-23 16:47:15 +00001225 if (const StmtExpr *SE = dyn_cast<StmtExpr>(e)) {
1226 const CompoundStmt *CS = SE->getSubStmt();
Aaron Ballmanc7e4e212014-03-17 14:19:37 +00001227 for (const auto *BI : CS->body())
1228 if (const auto *E = dyn_cast<Expr>(BI)) {
Fariborz Jahanian797f1e22011-08-23 16:47:15 +00001229 if (isCapturedBy(var, E))
1230 return true;
Fariborz Jahanian5c4b2ca2011-08-25 00:06:26 +00001231 }
Aaron Ballmanc7e4e212014-03-17 14:19:37 +00001232 else if (const auto *DS = dyn_cast<DeclStmt>(BI)) {
Fariborz Jahanian5c4b2ca2011-08-25 00:06:26 +00001233 // special case declarations
Aaron Ballman535bbcc2014-03-14 17:01:24 +00001234 for (const auto *I : DS->decls()) {
1235 if (const auto *VD = dyn_cast<VarDecl>((I))) {
1236 const Expr *Init = VD->getInit();
Fariborz Jahanian5c4b2ca2011-08-25 00:06:26 +00001237 if (Init && isCapturedBy(var, Init))
1238 return true;
1239 }
1240 }
1241 }
1242 else
1243 // FIXME. Make safe assumption assuming arbitrary statements cause capturing.
1244 // Later, provide code to poke into statements for capture analysis.
1245 return true;
Fariborz Jahanian797f1e22011-08-23 16:47:15 +00001246 return false;
1247 }
Eric Christopher31ab1302011-08-23 22:38:00 +00001248
Benjamin Kramer642f1732015-07-02 21:03:14 +00001249 for (const Stmt *SubStmt : e->children())
1250 if (isCapturedBy(var, cast<Expr>(SubStmt)))
John McCallc533cb72011-02-22 06:44:22 +00001251 return true;
1252
1253 return false;
1254}
1255
Douglas Gregor82e1af22011-07-01 21:08:19 +00001256/// \brief Determine whether the given initializer is trivial in the sense
1257/// that it requires no code to be generated.
Alexey Bataev4a5bb772014-10-08 14:01:46 +00001258bool CodeGenFunction::isTrivialInitializer(const Expr *Init) {
Douglas Gregor82e1af22011-07-01 21:08:19 +00001259 if (!Init)
1260 return true;
Eric Christopher31ab1302011-08-23 22:38:00 +00001261
Douglas Gregor82e1af22011-07-01 21:08:19 +00001262 if (const CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init))
1263 if (CXXConstructorDecl *Constructor = Construct->getConstructor())
1264 if (Constructor->isTrivial() &&
1265 Constructor->isDefaultConstructor() &&
1266 !Construct->requiresZeroInitialization())
1267 return true;
Eric Christopher31ab1302011-08-23 22:38:00 +00001268
Douglas Gregor82e1af22011-07-01 21:08:19 +00001269 return false;
1270}
Eugene Zelenko0a4f3f42016-02-10 19:11:58 +00001271
John McCallc533cb72011-02-22 06:44:22 +00001272void CodeGenFunction::EmitAutoVarInit(const AutoVarEmission &emission) {
John McCall9e2e22f2011-02-22 07:16:58 +00001273 assert(emission.Variable && "emission was not valid!");
1274
John McCallc533cb72011-02-22 06:44:22 +00001275 // If this was emitted as a global constant, we're done.
1276 if (emission.wasEmittedAsGlobal()) return;
1277
John McCall9e2e22f2011-02-22 07:16:58 +00001278 const VarDecl &D = *emission.Variable;
Adrian Prantl95b24e92015-02-03 20:00:54 +00001279 auto DL = ApplyDebugLocation::CreateDefaultArtificial(*this, D.getLocation());
John McCallc533cb72011-02-22 06:44:22 +00001280 QualType type = D.getType();
1281
Chris Lattner07eb7332007-07-12 00:39:48 +00001282 // If this local has an initializer, emit it now.
Daniel Dunbarb6adc432009-07-19 06:58:07 +00001283 const Expr *Init = D.getInit();
1284
1285 // If we are at an unreachable point, we don't need to emit the initializer
1286 // unless it contains a label.
1287 if (!HaveInsertPoint()) {
John McCallc533cb72011-02-22 06:44:22 +00001288 if (!Init || !ContainsLabel(Init)) return;
1289 EnsureInsertPoint();
Daniel Dunbarb6adc432009-07-19 06:58:07 +00001290 }
1291
John McCall73064872011-03-31 01:59:53 +00001292 // Initialize the structure of a __block variable.
1293 if (emission.IsByRef)
1294 emitByrefStructureInit(emission);
Anders Carlssoncadb9a62009-02-07 23:51:38 +00001295
Akira Hatanaka7275da02018-02-28 07:15:55 +00001296 // Initialize the variable here if it doesn't have a initializer and it is a
1297 // C struct that is non-trivial to initialize or an array containing such a
1298 // struct.
1299 if (!Init &&
1300 type.isNonTrivialToPrimitiveDefaultInitialize() ==
1301 QualType::PDIK_Struct) {
1302 LValue Dst = MakeAddrLValue(emission.getAllocatedAddress(), type);
1303 if (emission.IsByRef)
1304 drillIntoBlockVariable(*this, Dst, &D);
1305 defaultInitNonTrivialCStructVar(Dst);
1306 return;
1307 }
1308
Douglas Gregor82e1af22011-07-01 21:08:19 +00001309 if (isTrivialInitializer(Init))
1310 return;
Eric Christopher31ab1302011-08-23 22:38:00 +00001311
John McCallc533cb72011-02-22 06:44:22 +00001312 // Check whether this is a byref variable that's potentially
1313 // captured and moved by its own initializer. If so, we'll need to
1314 // emit the initializer first, then copy into the variable.
1315 bool capturedByInit = emission.IsByRef && isCapturedBy(D, Init);
1316
John McCall7f416cc2015-09-08 08:05:57 +00001317 Address Loc =
1318 capturedByInit ? emission.Addr : emission.getObjectAddress(*this);
John McCallc533cb72011-02-22 06:44:22 +00001319
Craig Topper8a13c412014-05-21 05:09:00 +00001320 llvm::Constant *constant = nullptr;
Richard Smith2bcde3a2013-06-02 00:09:52 +00001321 if (emission.IsConstantAggregate || D.isConstexpr()) {
Richard Smithfddd3842011-12-30 21:15:51 +00001322 assert(!capturedByInit && "constant init contains a capturing block?");
John McCallde0fe072017-08-15 21:42:52 +00001323 constant = ConstantEmitter(*this).tryEmitAbstractForInitializer(D);
Richard Smithfddd3842011-12-30 21:15:51 +00001324 }
1325
1326 if (!constant) {
John McCall7f416cc2015-09-08 08:05:57 +00001327 LValue lv = MakeAddrLValue(Loc, type);
John McCall1553b192011-06-16 04:16:24 +00001328 lv.setNonGC(true);
David Blaikie66e41972015-01-14 07:38:27 +00001329 return EmitExprAsInit(Init, &D, lv, capturedByInit);
John McCall1553b192011-06-16 04:16:24 +00001330 }
John McCall91ca10f2011-03-08 09:11:50 +00001331
Richard Smith2bcde3a2013-06-02 00:09:52 +00001332 if (!emission.IsConstantAggregate) {
1333 // For simple scalar/complex initialization, store the value directly.
John McCall7f416cc2015-09-08 08:05:57 +00001334 LValue lv = MakeAddrLValue(Loc, type);
Richard Smith2bcde3a2013-06-02 00:09:52 +00001335 lv.setNonGC(true);
1336 return EmitStoreThroughLValue(RValue::get(constant), lv, true);
1337 }
1338
John McCallc533cb72011-02-22 06:44:22 +00001339 // If this is a simple aggregate initialization, we can optimize it
1340 // in various ways.
John McCall91ca10f2011-03-08 09:11:50 +00001341 bool isVolatile = type.isVolatileQualified();
John McCallc533cb72011-02-22 06:44:22 +00001342
John McCall91ca10f2011-03-08 09:11:50 +00001343 llvm::Value *SizeVal =
Eric Christopher31ab1302011-08-23 22:38:00 +00001344 llvm::ConstantInt::get(IntPtrTy,
John McCall91ca10f2011-03-08 09:11:50 +00001345 getContext().getTypeSizeInChars(type).getQuantity());
John McCallc533cb72011-02-22 06:44:22 +00001346
Yaxun Liubd382362017-10-23 17:49:26 +00001347 llvm::Type *BP = AllocaInt8PtrTy;
John McCall7f416cc2015-09-08 08:05:57 +00001348 if (Loc.getType() != BP)
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001349 Loc = Builder.CreateBitCast(Loc, BP);
Mon P Wangcc2ab0c2010-04-04 03:10:52 +00001350
John McCall91ca10f2011-03-08 09:11:50 +00001351 // If the initializer is all or mostly zeros, codegen with memset then do
1352 // a few stores afterward.
Eric Christopher31ab1302011-08-23 22:38:00 +00001353 if (shouldUseMemSetPlusStoresToInitialize(constant,
Micah Villmowdd31ca12012-10-08 16:25:52 +00001354 CGM.getDataLayout().getTypeAllocSize(constant->getType()))) {
John McCall91ca10f2011-03-08 09:11:50 +00001355 Builder.CreateMemSet(Loc, llvm::ConstantInt::get(Int8Ty, 0), SizeVal,
John McCall7f416cc2015-09-08 08:05:57 +00001356 isVolatile);
Benjamin Kramer29f9a002012-08-27 22:07:02 +00001357 // Zero and undef don't require a stores.
1358 if (!constant->isNullValue() && !isa<llvm::UndefValue>(constant)) {
Matt Arsenault935574a2018-02-08 19:37:09 +00001359 Loc = Builder.CreateBitCast(Loc,
1360 constant->getType()->getPointerTo(Loc.getAddressSpace()));
John McCall7f416cc2015-09-08 08:05:57 +00001361 emitStoresForInitAfterMemset(constant, Loc.getPointer(),
1362 isVolatile, Builder);
Fariborz Jahanianc6140732010-03-12 21:40:43 +00001363 }
John McCall91ca10f2011-03-08 09:11:50 +00001364 } else {
Eric Christopher31ab1302011-08-23 22:38:00 +00001365 // Otherwise, create a temporary global with the initializer then
John McCall91ca10f2011-03-08 09:11:50 +00001366 // memcpy from the global to the alloca.
Reid Kleckner453e0562014-10-08 01:07:54 +00001367 std::string Name = getStaticDeclName(CGM, D);
Alexey Baderabdcfc12016-10-31 10:26:31 +00001368 unsigned AS = 0;
1369 if (getLangOpts().OpenCL) {
1370 AS = CGM.getContext().getTargetAddressSpace(LangAS::opencl_constant);
1371 BP = llvm::PointerType::getInt8PtrTy(getLLVMContext(), AS);
1372 }
John McCall91ca10f2011-03-08 09:11:50 +00001373 llvm::GlobalVariable *GV =
1374 new llvm::GlobalVariable(CGM.getModule(), constant->getType(), true,
Eric Christopherb58b3e82011-08-24 00:33:55 +00001375 llvm::GlobalValue::PrivateLinkage,
Alexey Baderabdcfc12016-10-31 10:26:31 +00001376 constant, Name, nullptr,
1377 llvm::GlobalValue::NotThreadLocal, AS);
John McCall7f416cc2015-09-08 08:05:57 +00001378 GV->setAlignment(Loc.getAlignment().getQuantity());
Peter Collingbournebcf909d2016-06-14 21:02:05 +00001379 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
Eric Christopher31ab1302011-08-23 22:38:00 +00001380
John McCall7f416cc2015-09-08 08:05:57 +00001381 Address SrcPtr = Address(GV, Loc.getAlignment());
1382 if (SrcPtr.getType() != BP)
Benjamin Kramer76399eb2011-09-27 21:06:10 +00001383 SrcPtr = Builder.CreateBitCast(SrcPtr, BP);
John McCall91ca10f2011-03-08 09:11:50 +00001384
John McCall7f416cc2015-09-08 08:05:57 +00001385 Builder.CreateMemCpy(Loc, SrcPtr, SizeVal, isVolatile);
John McCall91ca10f2011-03-08 09:11:50 +00001386 }
1387}
1388
1389/// Emit an expression as an initializer for a variable at the given
1390/// location. The expression is not necessarily the normal
1391/// initializer for the variable, and the address is not necessarily
1392/// its normal location.
1393///
1394/// \param init the initializing expression
1395/// \param var the variable to act as if we're initializing
1396/// \param loc the address to initialize; its type is a pointer
1397/// to the LLVM mapping of the variable's type
1398/// \param alignment the alignment of the address
1399/// \param capturedByInit true if the variable is a __block variable
1400/// whose address is potentially changed by the initializer
David Blaikie73ca5692014-12-09 00:32:22 +00001401void CodeGenFunction::EmitExprAsInit(const Expr *init, const ValueDecl *D,
David Blaikie66e41972015-01-14 07:38:27 +00001402 LValue lvalue, bool capturedByInit) {
John McCall31168b02011-06-15 23:02:42 +00001403 QualType type = D->getType();
John McCall91ca10f2011-03-08 09:11:50 +00001404
1405 if (type->isReferenceType()) {
Richard Smitha1c9d4d2013-06-12 23:38:09 +00001406 RValue rvalue = EmitReferenceBindingToExpr(init);
Eric Christopher31ab1302011-08-23 22:38:00 +00001407 if (capturedByInit)
John McCall1553b192011-06-16 04:16:24 +00001408 drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
David Blaikie66e41972015-01-14 07:38:27 +00001409 EmitStoreThroughLValue(rvalue, lvalue, true);
John McCall47fb9502013-03-07 21:37:08 +00001410 return;
1411 }
1412 switch (getEvaluationKind(type)) {
1413 case TEK_Scalar:
David Blaikie66e41972015-01-14 07:38:27 +00001414 EmitScalarInit(init, D, lvalue, capturedByInit);
John McCall47fb9502013-03-07 21:37:08 +00001415 return;
1416 case TEK_Complex: {
John McCall91ca10f2011-03-08 09:11:50 +00001417 ComplexPairTy complex = EmitComplexExpr(init);
John McCall1553b192011-06-16 04:16:24 +00001418 if (capturedByInit)
1419 drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
David Blaikie66e41972015-01-14 07:38:27 +00001420 EmitStoreOfComplex(complex, lvalue, /*init*/ true);
John McCall47fb9502013-03-07 21:37:08 +00001421 return;
1422 }
1423 case TEK_Aggregate:
John McCalla8ec7eb2013-03-07 21:37:17 +00001424 if (type->isAtomicType()) {
1425 EmitAtomicInit(const_cast<Expr*>(init), lvalue);
1426 } else {
1427 // TODO: how can we delay here if D is captured by its initializer?
1428 EmitAggExpr(init, AggValueSlot::forLValue(lvalue,
Chad Rosier615ed1a2012-03-29 17:37:10 +00001429 AggValueSlot::IsDestructed,
John McCalla5efa732011-08-25 23:04:34 +00001430 AggValueSlot::DoesNotNeedGCBarriers,
Chad Rosier615ed1a2012-03-29 17:37:10 +00001431 AggValueSlot::IsNotAliased));
John McCalla8ec7eb2013-03-07 21:37:17 +00001432 }
John McCall47fb9502013-03-07 21:37:08 +00001433 return;
Fariborz Jahanianc6140732010-03-12 21:40:43 +00001434 }
John McCall47fb9502013-03-07 21:37:08 +00001435 llvm_unreachable("bad evaluation kind");
John McCallc533cb72011-02-22 06:44:22 +00001436}
John McCallbd309292010-07-06 01:34:17 +00001437
John McCall82fe67b2011-07-09 01:37:26 +00001438/// Enter a destroy cleanup for the given local variable.
1439void CodeGenFunction::emitAutoVarTypeCleanup(
1440 const CodeGenFunction::AutoVarEmission &emission,
1441 QualType::DestructionKind dtorKind) {
1442 assert(dtorKind != QualType::DK_none);
1443
1444 // Note that for __block variables, we want to destroy the
1445 // original stack object, not the possibly forwarded object.
John McCall7f416cc2015-09-08 08:05:57 +00001446 Address addr = emission.getObjectAddress(*this);
John McCall82fe67b2011-07-09 01:37:26 +00001447
1448 const VarDecl *var = emission.Variable;
1449 QualType type = var->getType();
1450
1451 CleanupKind cleanupKind = NormalAndEHCleanup;
Craig Topper8a13c412014-05-21 05:09:00 +00001452 CodeGenFunction::Destroyer *destroyer = nullptr;
John McCall82fe67b2011-07-09 01:37:26 +00001453
1454 switch (dtorKind) {
1455 case QualType::DK_none:
1456 llvm_unreachable("no cleanup for trivially-destructible variable");
1457
1458 case QualType::DK_cxx_destructor:
1459 // If there's an NRVO flag on the emission, we need a different
1460 // cleanup.
1461 if (emission.NRVOFlag) {
1462 assert(!type->isArrayType());
1463 CXXDestructorDecl *dtor = type->getAsCXXRecordDecl()->getDestructor();
John McCall7f416cc2015-09-08 08:05:57 +00001464 EHStack.pushCleanup<DestroyNRVOVariable>(cleanupKind, addr,
1465 dtor, emission.NRVOFlag);
John McCall82fe67b2011-07-09 01:37:26 +00001466 return;
1467 }
1468 break;
1469
1470 case QualType::DK_objc_strong_lifetime:
1471 // Suppress cleanups for pseudo-strong variables.
1472 if (var->isARCPseudoStrong()) return;
Eric Christopher31ab1302011-08-23 22:38:00 +00001473
John McCall82fe67b2011-07-09 01:37:26 +00001474 // Otherwise, consider whether to use an EH cleanup or not.
1475 cleanupKind = getARCCleanupKind();
1476
1477 // Use the imprecise destroyer by default.
1478 if (!var->hasAttr<ObjCPreciseLifetimeAttr>())
1479 destroyer = CodeGenFunction::destroyARCStrongImprecise;
1480 break;
1481
1482 case QualType::DK_objc_weak_lifetime:
1483 break;
Akira Hatanaka7275da02018-02-28 07:15:55 +00001484
1485 case QualType::DK_nontrivial_c_struct:
1486 destroyer = CodeGenFunction::destroyNonTrivialCStruct;
1487 break;
John McCall82fe67b2011-07-09 01:37:26 +00001488 }
1489
1490 // If we haven't chosen a more specific destroyer, use the default.
Peter Collingbourne1425b452012-01-26 03:33:36 +00001491 if (!destroyer) destroyer = getDestroyer(dtorKind);
John McCall178360e2011-07-11 08:38:19 +00001492
Sylvestre Ledru33b5baf2012-09-27 10:16:10 +00001493 // Use an EH cleanup in array destructors iff the destructor itself
John McCall178360e2011-07-11 08:38:19 +00001494 // is being pushed as an EH cleanup.
1495 bool useEHCleanup = (cleanupKind & EHCleanup);
1496 EHStack.pushCleanup<DestroyObject>(cleanupKind, addr, type, destroyer,
1497 useEHCleanup);
John McCall82fe67b2011-07-09 01:37:26 +00001498}
1499
John McCallc533cb72011-02-22 06:44:22 +00001500void CodeGenFunction::EmitAutoVarCleanups(const AutoVarEmission &emission) {
John McCall9e2e22f2011-02-22 07:16:58 +00001501 assert(emission.Variable && "emission was not valid!");
1502
John McCallc533cb72011-02-22 06:44:22 +00001503 // If this was emitted as a global constant, we're done.
1504 if (emission.wasEmittedAsGlobal()) return;
1505
John McCall8c38d352012-04-13 18:44:05 +00001506 // If we don't have an insertion point, we're done. Sema prevents
1507 // us from jumping into any of these scopes anyway.
1508 if (!HaveInsertPoint()) return;
1509
John McCall9e2e22f2011-02-22 07:16:58 +00001510 const VarDecl &D = *emission.Variable;
John McCallc533cb72011-02-22 06:44:22 +00001511
John McCall82fe67b2011-07-09 01:37:26 +00001512 // Check the type for a cleanup.
1513 if (QualType::DestructionKind dtorKind = D.getType().isDestructedType())
1514 emitAutoVarTypeCleanup(emission, dtorKind);
John McCall31168b02011-06-15 23:02:42 +00001515
John McCall1bd25562011-06-24 23:21:27 +00001516 // In GC mode, honor objc_precise_lifetime.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001517 if (getLangOpts().getGC() != LangOptions::NonGC &&
John McCall1bd25562011-06-24 23:21:27 +00001518 D.hasAttr<ObjCPreciseLifetimeAttr>()) {
1519 EHStack.pushCleanup<ExtendGCLifetime>(NormalCleanup, &D);
1520 }
1521
John McCallc533cb72011-02-22 06:44:22 +00001522 // Handle the cleanup attribute.
Argyrios Kyrtzidisb4b64ca2009-06-30 02:34:44 +00001523 if (const CleanupAttr *CA = D.getAttr<CleanupAttr>()) {
Anders Carlssoncadb9a62009-02-07 23:51:38 +00001524 const FunctionDecl *FD = CA->getFunctionDecl();
Mike Stump11289f42009-09-09 15:08:12 +00001525
John McCallc533cb72011-02-22 06:44:22 +00001526 llvm::Constant *F = CGM.GetAddrOfFunction(FD);
Anders Carlssoncadb9a62009-02-07 23:51:38 +00001527 assert(F && "Could not find function!");
Mike Stump11289f42009-09-09 15:08:12 +00001528
John McCalla729c622012-02-17 03:33:10 +00001529 const CGFunctionInfo &Info = CGM.getTypes().arrangeFunctionDeclaration(FD);
John McCallc533cb72011-02-22 06:44:22 +00001530 EHStack.pushCleanup<CallCleanupFunction>(NormalAndEHCleanup, F, &Info, &D);
Anders Carlssoncadb9a62009-02-07 23:51:38 +00001531 }
Mike Stump626aecc2009-03-05 01:23:13 +00001532
John McCallc533cb72011-02-22 06:44:22 +00001533 // If this is a block variable, call _Block_object_destroy
1534 // (on the unforwarded address).
John McCall73064872011-03-31 01:59:53 +00001535 if (emission.IsByRef)
1536 enterByrefCleanup(emission);
Chris Lattner03df1222007-06-02 04:53:11 +00001537}
Chris Lattner53621a52007-06-13 20:44:40 +00001538
Peter Collingbourne1425b452012-01-26 03:33:36 +00001539CodeGenFunction::Destroyer *
John McCall82fe67b2011-07-09 01:37:26 +00001540CodeGenFunction::getDestroyer(QualType::DestructionKind kind) {
1541 switch (kind) {
1542 case QualType::DK_none: llvm_unreachable("no destroyer for trivial dtor");
John McCallc2f00012011-07-09 09:09:00 +00001543 case QualType::DK_cxx_destructor:
Peter Collingbourne1425b452012-01-26 03:33:36 +00001544 return destroyCXXObject;
John McCallc2f00012011-07-09 09:09:00 +00001545 case QualType::DK_objc_strong_lifetime:
Peter Collingbourne1425b452012-01-26 03:33:36 +00001546 return destroyARCStrongPrecise;
John McCallc2f00012011-07-09 09:09:00 +00001547 case QualType::DK_objc_weak_lifetime:
Peter Collingbourne1425b452012-01-26 03:33:36 +00001548 return destroyARCWeak;
Akira Hatanaka7275da02018-02-28 07:15:55 +00001549 case QualType::DK_nontrivial_c_struct:
1550 return destroyNonTrivialCStruct;
John McCall82fe67b2011-07-09 01:37:26 +00001551 }
Matt Beaumont-Gay934bbf52012-01-27 00:46:27 +00001552 llvm_unreachable("Unknown DestructionKind");
John McCall82fe67b2011-07-09 01:37:26 +00001553}
1554
John McCall12cc42a2013-02-01 05:11:40 +00001555/// pushEHDestroy - Push the standard destructor for the given type as
1556/// an EH-only cleanup.
1557void CodeGenFunction::pushEHDestroy(QualType::DestructionKind dtorKind,
John McCall7f416cc2015-09-08 08:05:57 +00001558 Address addr, QualType type) {
John McCall12cc42a2013-02-01 05:11:40 +00001559 assert(dtorKind && "cannot push destructor for trivial type");
1560 assert(needsEHCleanup(dtorKind));
1561
1562 pushDestroy(EHCleanup, addr, type, getDestroyer(dtorKind), true);
1563}
1564
1565/// pushDestroy - Push the standard destructor for the given type as
1566/// at least a normal cleanup.
John McCall4bd0fb12011-07-12 16:41:08 +00001567void CodeGenFunction::pushDestroy(QualType::DestructionKind dtorKind,
John McCall7f416cc2015-09-08 08:05:57 +00001568 Address addr, QualType type) {
John McCall4bd0fb12011-07-12 16:41:08 +00001569 assert(dtorKind && "cannot push destructor for trivial type");
1570
1571 CleanupKind cleanupKind = getCleanupKind(dtorKind);
1572 pushDestroy(cleanupKind, addr, type, getDestroyer(dtorKind),
1573 cleanupKind & EHCleanup);
1574}
1575
John McCall7f416cc2015-09-08 08:05:57 +00001576void CodeGenFunction::pushDestroy(CleanupKind cleanupKind, Address addr,
Peter Collingbourne1425b452012-01-26 03:33:36 +00001577 QualType type, Destroyer *destroyer,
John McCall178360e2011-07-11 08:38:19 +00001578 bool useEHCleanupForArray) {
John McCall4bd0fb12011-07-12 16:41:08 +00001579 pushFullExprCleanup<DestroyObject>(cleanupKind, addr, type,
1580 destroyer, useEHCleanupForArray);
John McCall82fe67b2011-07-09 01:37:26 +00001581}
1582
John McCall7f416cc2015-09-08 08:05:57 +00001583void CodeGenFunction::pushStackRestore(CleanupKind Kind, Address SPMem) {
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001584 EHStack.pushCleanup<CallStackRestore>(Kind, SPMem);
1585}
1586
Richard Smith736a9472013-06-12 20:42:33 +00001587void CodeGenFunction::pushLifetimeExtendedDestroy(
John McCall7f416cc2015-09-08 08:05:57 +00001588 CleanupKind cleanupKind, Address addr, QualType type,
Richard Smith736a9472013-06-12 20:42:33 +00001589 Destroyer *destroyer, bool useEHCleanupForArray) {
1590 assert(!isInConditionalBranch() &&
1591 "performing lifetime extension from within conditional");
1592
1593 // Push an EH-only cleanup for the object now.
1594 // FIXME: When popping normal cleanups, we need to keep this EH cleanup
1595 // around in case a temporary's destructor throws an exception.
1596 if (cleanupKind & EHCleanup)
1597 EHStack.pushCleanup<DestroyObject>(
1598 static_cast<CleanupKind>(cleanupKind & ~NormalCleanup), addr, type,
1599 destroyer, useEHCleanupForArray);
1600
1601 // Remember that we need to push a full cleanup for the object at the
1602 // end of the full-expression.
1603 pushCleanupAfterFullExpr<DestroyObject>(
1604 cleanupKind, addr, type, destroyer, useEHCleanupForArray);
1605}
1606
John McCall178360e2011-07-11 08:38:19 +00001607/// emitDestroy - Immediately perform the destruction of the given
1608/// object.
1609///
1610/// \param addr - the address of the object; a type*
1611/// \param type - the type of the object; if an array type, all
1612/// objects are destroyed in reverse order
1613/// \param destroyer - the function to call to destroy individual
1614/// elements
1615/// \param useEHCleanupForArray - whether an EH cleanup should be
1616/// used when destroying array elements, in case one of the
1617/// destructions throws an exception
John McCall7f416cc2015-09-08 08:05:57 +00001618void CodeGenFunction::emitDestroy(Address addr, QualType type,
Peter Collingbourne1425b452012-01-26 03:33:36 +00001619 Destroyer *destroyer,
John McCall178360e2011-07-11 08:38:19 +00001620 bool useEHCleanupForArray) {
John McCall82fe67b2011-07-09 01:37:26 +00001621 const ArrayType *arrayType = getContext().getAsArrayType(type);
1622 if (!arrayType)
1623 return destroyer(*this, addr, type);
1624
John McCall7f416cc2015-09-08 08:05:57 +00001625 llvm::Value *length = emitArrayLength(arrayType, type, addr);
1626
1627 CharUnits elementAlign =
1628 addr.getAlignment()
1629 .alignmentOfArrayElement(getContext().getTypeSizeInChars(type));
John McCall97eab0a2011-07-13 08:09:46 +00001630
1631 // Normally we have to check whether the array is zero-length.
1632 bool checkZeroLength = true;
1633
1634 // But if the array length is constant, we can suppress that.
1635 if (llvm::ConstantInt *constLength = dyn_cast<llvm::ConstantInt>(length)) {
1636 // ...and if it's constant zero, we can just skip the entire thing.
1637 if (constLength->isZero()) return;
1638 checkZeroLength = false;
1639 }
1640
John McCall7f416cc2015-09-08 08:05:57 +00001641 llvm::Value *begin = addr.getPointer();
John McCall82fe67b2011-07-09 01:37:26 +00001642 llvm::Value *end = Builder.CreateInBoundsGEP(begin, length);
John McCall7f416cc2015-09-08 08:05:57 +00001643 emitArrayDestroy(begin, end, type, elementAlign, destroyer,
John McCall97eab0a2011-07-13 08:09:46 +00001644 checkZeroLength, useEHCleanupForArray);
John McCall82fe67b2011-07-09 01:37:26 +00001645}
1646
John McCall178360e2011-07-11 08:38:19 +00001647/// emitArrayDestroy - Destroys all the elements of the given array,
1648/// beginning from last to first. The array cannot be zero-length.
1649///
1650/// \param begin - a type* denoting the first element of the array
1651/// \param end - a type* denoting one past the end of the array
NAKAMURA Takumiff7a9252015-09-08 09:42:41 +00001652/// \param elementType - the element type of the array
John McCall178360e2011-07-11 08:38:19 +00001653/// \param destroyer - the function to call to destroy elements
1654/// \param useEHCleanup - whether to push an EH cleanup to destroy
1655/// the remaining elements in case the destruction of a single
1656/// element throws
John McCall82fe67b2011-07-09 01:37:26 +00001657void CodeGenFunction::emitArrayDestroy(llvm::Value *begin,
1658 llvm::Value *end,
John McCall7f416cc2015-09-08 08:05:57 +00001659 QualType elementType,
1660 CharUnits elementAlign,
Peter Collingbourne1425b452012-01-26 03:33:36 +00001661 Destroyer *destroyer,
John McCall97eab0a2011-07-13 08:09:46 +00001662 bool checkZeroLength,
John McCall178360e2011-07-11 08:38:19 +00001663 bool useEHCleanup) {
John McCall7f416cc2015-09-08 08:05:57 +00001664 assert(!elementType->isArrayType());
John McCall82fe67b2011-07-09 01:37:26 +00001665
1666 // The basic structure here is a do-while loop, because we don't
1667 // need to check for the zero-element case.
1668 llvm::BasicBlock *bodyBB = createBasicBlock("arraydestroy.body");
1669 llvm::BasicBlock *doneBB = createBasicBlock("arraydestroy.done");
1670
John McCall97eab0a2011-07-13 08:09:46 +00001671 if (checkZeroLength) {
1672 llvm::Value *isEmpty = Builder.CreateICmpEQ(begin, end,
1673 "arraydestroy.isempty");
1674 Builder.CreateCondBr(isEmpty, doneBB, bodyBB);
1675 }
1676
John McCall82fe67b2011-07-09 01:37:26 +00001677 // Enter the loop body, making that address the current address.
1678 llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
1679 EmitBlock(bodyBB);
1680 llvm::PHINode *elementPast =
1681 Builder.CreatePHI(begin->getType(), 2, "arraydestroy.elementPast");
1682 elementPast->addIncoming(end, entryBB);
1683
1684 // Shift the address back by one element.
1685 llvm::Value *negativeOne = llvm::ConstantInt::get(SizeTy, -1, true);
1686 llvm::Value *element = Builder.CreateInBoundsGEP(elementPast, negativeOne,
1687 "arraydestroy.element");
1688
John McCall178360e2011-07-11 08:38:19 +00001689 if (useEHCleanup)
John McCall7f416cc2015-09-08 08:05:57 +00001690 pushRegularPartialArrayCleanup(begin, element, elementType, elementAlign,
1691 destroyer);
John McCall178360e2011-07-11 08:38:19 +00001692
John McCall82fe67b2011-07-09 01:37:26 +00001693 // Perform the actual destruction there.
John McCall7f416cc2015-09-08 08:05:57 +00001694 destroyer(*this, Address(element, elementAlign), elementType);
John McCall82fe67b2011-07-09 01:37:26 +00001695
John McCall178360e2011-07-11 08:38:19 +00001696 if (useEHCleanup)
1697 PopCleanupBlock();
1698
John McCall82fe67b2011-07-09 01:37:26 +00001699 // Check whether we've reached the end.
1700 llvm::Value *done = Builder.CreateICmpEQ(element, begin, "arraydestroy.done");
1701 Builder.CreateCondBr(done, doneBB, bodyBB);
1702 elementPast->addIncoming(element, Builder.GetInsertBlock());
1703
1704 // Done.
1705 EmitBlock(doneBB);
1706}
1707
John McCall178360e2011-07-11 08:38:19 +00001708/// Perform partial array destruction as if in an EH cleanup. Unlike
1709/// emitArrayDestroy, the element type here may still be an array type.
John McCall178360e2011-07-11 08:38:19 +00001710static void emitPartialArrayDestroy(CodeGenFunction &CGF,
1711 llvm::Value *begin, llvm::Value *end,
John McCall7f416cc2015-09-08 08:05:57 +00001712 QualType type, CharUnits elementAlign,
Peter Collingbourne1425b452012-01-26 03:33:36 +00001713 CodeGenFunction::Destroyer *destroyer) {
John McCall178360e2011-07-11 08:38:19 +00001714 // If the element type is itself an array, drill down.
John McCall97eab0a2011-07-13 08:09:46 +00001715 unsigned arrayDepth = 0;
John McCall178360e2011-07-11 08:38:19 +00001716 while (const ArrayType *arrayType = CGF.getContext().getAsArrayType(type)) {
1717 // VLAs don't require a GEP index to walk into.
1718 if (!isa<VariableArrayType>(arrayType))
John McCall97eab0a2011-07-13 08:09:46 +00001719 arrayDepth++;
John McCall178360e2011-07-11 08:38:19 +00001720 type = arrayType->getElementType();
1721 }
John McCall97eab0a2011-07-13 08:09:46 +00001722
1723 if (arrayDepth) {
John McCallf0f0b7a2015-09-14 18:57:08 +00001724 llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
John McCall97eab0a2011-07-13 08:09:46 +00001725
John McCallf0f0b7a2015-09-14 18:57:08 +00001726 SmallVector<llvm::Value*,4> gepIndices(arrayDepth+1, zero);
Jay Foad040dd822011-07-22 08:16:57 +00001727 begin = CGF.Builder.CreateInBoundsGEP(begin, gepIndices, "pad.arraybegin");
1728 end = CGF.Builder.CreateInBoundsGEP(end, gepIndices, "pad.arrayend");
John McCall178360e2011-07-11 08:38:19 +00001729 }
1730
John McCall97eab0a2011-07-13 08:09:46 +00001731 // Destroy the array. We don't ever need an EH cleanup because we
1732 // assume that we're in an EH cleanup ourselves, so a throwing
1733 // destructor causes an immediate terminate.
John McCall7f416cc2015-09-08 08:05:57 +00001734 CGF.emitArrayDestroy(begin, end, type, elementAlign, destroyer,
John McCall97eab0a2011-07-13 08:09:46 +00001735 /*checkZeroLength*/ true, /*useEHCleanup*/ false);
John McCall178360e2011-07-11 08:38:19 +00001736}
1737
John McCall82fe67b2011-07-09 01:37:26 +00001738namespace {
John McCall178360e2011-07-11 08:38:19 +00001739 /// RegularPartialArrayDestroy - a cleanup which performs a partial
1740 /// array destroy where the end pointer is regularly determined and
1741 /// does not need to be loaded from a local.
David Blaikie7e70d682015-08-18 22:40:54 +00001742 class RegularPartialArrayDestroy final : public EHScopeStack::Cleanup {
John McCall178360e2011-07-11 08:38:19 +00001743 llvm::Value *ArrayBegin;
1744 llvm::Value *ArrayEnd;
1745 QualType ElementType;
Peter Collingbourne1425b452012-01-26 03:33:36 +00001746 CodeGenFunction::Destroyer *Destroyer;
John McCall7f416cc2015-09-08 08:05:57 +00001747 CharUnits ElementAlign;
John McCall178360e2011-07-11 08:38:19 +00001748 public:
1749 RegularPartialArrayDestroy(llvm::Value *arrayBegin, llvm::Value *arrayEnd,
John McCall7f416cc2015-09-08 08:05:57 +00001750 QualType elementType, CharUnits elementAlign,
John McCall178360e2011-07-11 08:38:19 +00001751 CodeGenFunction::Destroyer *destroyer)
1752 : ArrayBegin(arrayBegin), ArrayEnd(arrayEnd),
John McCall7f416cc2015-09-08 08:05:57 +00001753 ElementType(elementType), Destroyer(destroyer),
1754 ElementAlign(elementAlign) {}
John McCall178360e2011-07-11 08:38:19 +00001755
Craig Topper4f12f102014-03-12 06:41:41 +00001756 void Emit(CodeGenFunction &CGF, Flags flags) override {
John McCall178360e2011-07-11 08:38:19 +00001757 emitPartialArrayDestroy(CGF, ArrayBegin, ArrayEnd,
John McCall7f416cc2015-09-08 08:05:57 +00001758 ElementType, ElementAlign, Destroyer);
John McCall178360e2011-07-11 08:38:19 +00001759 }
1760 };
1761
1762 /// IrregularPartialArrayDestroy - a cleanup which performs a
1763 /// partial array destroy where the end pointer is irregularly
1764 /// determined and must be loaded from a local.
David Blaikie7e70d682015-08-18 22:40:54 +00001765 class IrregularPartialArrayDestroy final : public EHScopeStack::Cleanup {
John McCall82fe67b2011-07-09 01:37:26 +00001766 llvm::Value *ArrayBegin;
John McCall7f416cc2015-09-08 08:05:57 +00001767 Address ArrayEndPointer;
John McCall82fe67b2011-07-09 01:37:26 +00001768 QualType ElementType;
Peter Collingbourne1425b452012-01-26 03:33:36 +00001769 CodeGenFunction::Destroyer *Destroyer;
John McCall7f416cc2015-09-08 08:05:57 +00001770 CharUnits ElementAlign;
John McCall82fe67b2011-07-09 01:37:26 +00001771 public:
John McCall178360e2011-07-11 08:38:19 +00001772 IrregularPartialArrayDestroy(llvm::Value *arrayBegin,
John McCall7f416cc2015-09-08 08:05:57 +00001773 Address arrayEndPointer,
John McCall178360e2011-07-11 08:38:19 +00001774 QualType elementType,
John McCall7f416cc2015-09-08 08:05:57 +00001775 CharUnits elementAlign,
John McCall178360e2011-07-11 08:38:19 +00001776 CodeGenFunction::Destroyer *destroyer)
John McCall82fe67b2011-07-09 01:37:26 +00001777 : ArrayBegin(arrayBegin), ArrayEndPointer(arrayEndPointer),
John McCall7f416cc2015-09-08 08:05:57 +00001778 ElementType(elementType), Destroyer(destroyer),
1779 ElementAlign(elementAlign) {}
John McCall82fe67b2011-07-09 01:37:26 +00001780
Craig Topper4f12f102014-03-12 06:41:41 +00001781 void Emit(CodeGenFunction &CGF, Flags flags) override {
John McCall82fe67b2011-07-09 01:37:26 +00001782 llvm::Value *arrayEnd = CGF.Builder.CreateLoad(ArrayEndPointer);
John McCall178360e2011-07-11 08:38:19 +00001783 emitPartialArrayDestroy(CGF, ArrayBegin, arrayEnd,
John McCall7f416cc2015-09-08 08:05:57 +00001784 ElementType, ElementAlign, Destroyer);
John McCall82fe67b2011-07-09 01:37:26 +00001785 }
1786 };
Eugene Zelenko0a4f3f42016-02-10 19:11:58 +00001787} // end anonymous namespace
John McCall82fe67b2011-07-09 01:37:26 +00001788
John McCall178360e2011-07-11 08:38:19 +00001789/// pushIrregularPartialArrayCleanup - Push an EH cleanup to destroy
John McCall82fe67b2011-07-09 01:37:26 +00001790/// already-constructed elements of the given array. The cleanup
John McCall178360e2011-07-11 08:38:19 +00001791/// may be popped with DeactivateCleanupBlock or PopCleanupBlock.
Eric Christopher31ab1302011-08-23 22:38:00 +00001792///
John McCall82fe67b2011-07-09 01:37:26 +00001793/// \param elementType - the immediate element type of the array;
1794/// possibly still an array type
John McCall4bd0fb12011-07-12 16:41:08 +00001795void CodeGenFunction::pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin,
John McCall7f416cc2015-09-08 08:05:57 +00001796 Address arrayEndPointer,
John McCall178360e2011-07-11 08:38:19 +00001797 QualType elementType,
John McCall7f416cc2015-09-08 08:05:57 +00001798 CharUnits elementAlign,
Peter Collingbourne1425b452012-01-26 03:33:36 +00001799 Destroyer *destroyer) {
John McCall4bd0fb12011-07-12 16:41:08 +00001800 pushFullExprCleanup<IrregularPartialArrayDestroy>(EHCleanup,
1801 arrayBegin, arrayEndPointer,
John McCall7f416cc2015-09-08 08:05:57 +00001802 elementType, elementAlign,
1803 destroyer);
John McCall178360e2011-07-11 08:38:19 +00001804}
1805
1806/// pushRegularPartialArrayCleanup - Push an EH cleanup to destroy
1807/// already-constructed elements of the given array. The cleanup
1808/// may be popped with DeactivateCleanupBlock or PopCleanupBlock.
Eric Christopher31ab1302011-08-23 22:38:00 +00001809///
John McCall178360e2011-07-11 08:38:19 +00001810/// \param elementType - the immediate element type of the array;
1811/// possibly still an array type
John McCall178360e2011-07-11 08:38:19 +00001812void CodeGenFunction::pushRegularPartialArrayCleanup(llvm::Value *arrayBegin,
1813 llvm::Value *arrayEnd,
1814 QualType elementType,
John McCall7f416cc2015-09-08 08:05:57 +00001815 CharUnits elementAlign,
Peter Collingbourne1425b452012-01-26 03:33:36 +00001816 Destroyer *destroyer) {
John McCall4bd0fb12011-07-12 16:41:08 +00001817 pushFullExprCleanup<RegularPartialArrayDestroy>(EHCleanup,
John McCall178360e2011-07-11 08:38:19 +00001818 arrayBegin, arrayEnd,
John McCall7f416cc2015-09-08 08:05:57 +00001819 elementType, elementAlign,
1820 destroyer);
John McCall82fe67b2011-07-09 01:37:26 +00001821}
1822
Nadav Rotem1da30942013-03-23 06:43:35 +00001823/// Lazily declare the @llvm.lifetime.start intrinsic.
1824llvm::Constant *CodeGenModule::getLLVMLifetimeStartFn() {
Matt Arsenaultd9729492017-04-10 20:18:45 +00001825 if (LifetimeStartFn)
1826 return LifetimeStartFn;
Nadav Rotem1da30942013-03-23 06:43:35 +00001827 LifetimeStartFn = llvm::Intrinsic::getDeclaration(&getModule(),
Yaxun Liu7f7f3232017-04-17 20:03:11 +00001828 llvm::Intrinsic::lifetime_start, AllocaInt8PtrTy);
Nadav Rotem1da30942013-03-23 06:43:35 +00001829 return LifetimeStartFn;
1830}
1831
1832/// Lazily declare the @llvm.lifetime.end intrinsic.
1833llvm::Constant *CodeGenModule::getLLVMLifetimeEndFn() {
Matt Arsenaultd9729492017-04-10 20:18:45 +00001834 if (LifetimeEndFn)
1835 return LifetimeEndFn;
Nadav Rotem1da30942013-03-23 06:43:35 +00001836 LifetimeEndFn = llvm::Intrinsic::getDeclaration(&getModule(),
Yaxun Liu7f7f3232017-04-17 20:03:11 +00001837 llvm::Intrinsic::lifetime_end, AllocaInt8PtrTy);
Nadav Rotem1da30942013-03-23 06:43:35 +00001838 return LifetimeEndFn;
1839}
1840
John McCall31168b02011-06-15 23:02:42 +00001841namespace {
1842 /// A cleanup to perform a release of an object at the end of a
1843 /// function. This is used to balance out the incoming +1 of a
1844 /// ns_consumed argument when we can't reasonably do that just by
1845 /// not doing the initial retain for a __block argument.
David Blaikie7e70d682015-08-18 22:40:54 +00001846 struct ConsumeARCParameter final : EHScopeStack::Cleanup {
John McCallcdda29c2013-03-13 03:10:54 +00001847 ConsumeARCParameter(llvm::Value *param,
1848 ARCPreciseLifetime_t precise)
1849 : Param(param), Precise(precise) {}
John McCall31168b02011-06-15 23:02:42 +00001850
1851 llvm::Value *Param;
John McCallcdda29c2013-03-13 03:10:54 +00001852 ARCPreciseLifetime_t Precise;
John McCall31168b02011-06-15 23:02:42 +00001853
Craig Topper4f12f102014-03-12 06:41:41 +00001854 void Emit(CodeGenFunction &CGF, Flags flags) override {
John McCallcdda29c2013-03-13 03:10:54 +00001855 CGF.EmitARCRelease(Param, Precise);
John McCall31168b02011-06-15 23:02:42 +00001856 }
1857 };
Eugene Zelenko0a4f3f42016-02-10 19:11:58 +00001858} // end anonymous namespace
John McCall31168b02011-06-15 23:02:42 +00001859
Mike Stump11289f42009-09-09 15:08:12 +00001860/// Emit an alloca (or GlobalValue depending on target)
Chris Lattnerb781dc792008-05-08 05:58:21 +00001861/// for the specified parameter and set up LocalDeclMap.
John McCall7f416cc2015-09-08 08:05:57 +00001862void CodeGenFunction::EmitParmDecl(const VarDecl &D, ParamValue Arg,
1863 unsigned ArgNo) {
Daniel Dunbara94ecd22008-08-16 03:19:19 +00001864 // FIXME: Why isn't ImplicitParamDecl a ParmVarDecl?
Sanjiv Guptad7959242008-10-31 09:52:39 +00001865 assert((isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D)) &&
Daniel Dunbara94ecd22008-08-16 03:19:19 +00001866 "Invalid argument to EmitParmDecl");
John McCall147d0212011-02-22 22:38:33 +00001867
John McCall7f416cc2015-09-08 08:05:57 +00001868 Arg.getAnyValue()->setName(D.getName());
John McCall147d0212011-02-22 22:38:33 +00001869
Adrian Prantl51936dd2013-03-14 17:53:33 +00001870 QualType Ty = D.getType();
1871
John McCall147d0212011-02-22 22:38:33 +00001872 // Use better IR generation for certain implicit parameters.
John McCall7f416cc2015-09-08 08:05:57 +00001873 if (auto IPD = dyn_cast<ImplicitParamDecl>(&D)) {
John McCall147d0212011-02-22 22:38:33 +00001874 // The only implicit argument a block has is its literal.
Saleem Abdulrasoolc1b46382018-02-21 21:47:51 +00001875 // This may be passed as an inalloca'ed value on Windows x86.
John McCall147d0212011-02-22 22:38:33 +00001876 if (BlockInfo) {
Saleem Abdulrasoolc1b46382018-02-21 21:47:51 +00001877 llvm::Value *V = Arg.isIndirect()
1878 ? Builder.CreateLoad(Arg.getIndirectAddress())
1879 : Arg.getDirectValue();
1880 setBlockContextParameter(IPD, ArgNo, V);
John McCall147d0212011-02-22 22:38:33 +00001881 return;
1882 }
1883 }
1884
John McCall7f416cc2015-09-08 08:05:57 +00001885 Address DeclPtr = Address::invalid();
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001886 bool DoStore = false;
1887 bool IsScalar = hasScalarEvaluationKind(Ty);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001888 // If we already have a pointer to the argument, reuse the input pointer.
John McCall7f416cc2015-09-08 08:05:57 +00001889 if (Arg.isIndirect()) {
1890 DeclPtr = Arg.getIndirectAddress();
Reid Kleckner5e8edba2014-04-02 00:16:53 +00001891 // If we have a prettier pointer type at this point, bitcast to that.
John McCall7f416cc2015-09-08 08:05:57 +00001892 unsigned AS = DeclPtr.getType()->getAddressSpace();
Reid Kleckner5e8edba2014-04-02 00:16:53 +00001893 llvm::Type *IRTy = ConvertTypeForMem(Ty)->getPointerTo(AS);
John McCall7f416cc2015-09-08 08:05:57 +00001894 if (DeclPtr.getType() != IRTy)
1895 DeclPtr = Builder.CreateBitCast(DeclPtr, IRTy, D.getName());
Yaxun Liu5b330e82018-03-15 15:25:19 +00001896 // Indirect argument is in alloca address space, which may be different
1897 // from the default address space.
1898 auto AllocaAS = CGM.getASTAllocaAddressSpace();
1899 auto *V = DeclPtr.getPointer();
1900 auto SrcLangAS = getLangOpts().OpenCL ? LangAS::opencl_private : AllocaAS;
1901 auto DestLangAS =
1902 getLangOpts().OpenCL ? LangAS::opencl_private : LangAS::Default;
1903 if (SrcLangAS != DestLangAS) {
1904 assert(getContext().getTargetAddressSpace(SrcLangAS) ==
1905 CGM.getDataLayout().getAllocaAddrSpace());
1906 auto DestAS = getContext().getTargetAddressSpace(DestLangAS);
1907 auto *T = V->getType()->getPointerElementType()->getPointerTo(DestAS);
1908 DeclPtr = Address(getTargetHooks().performAddrSpaceCast(
1909 *this, V, SrcLangAS, DestLangAS, T, true),
1910 DeclPtr.getAlignment());
1911 }
John McCall7f416cc2015-09-08 08:05:57 +00001912
Reid Kleckner23f4c4b2013-06-21 12:45:15 +00001913 // Push a destructor cleanup for this parameter if the ABI requires it.
Reid Kleckner19819442014-07-25 21:39:46 +00001914 // Don't push a cleanup in a thunk for a method that will also emit a
1915 // cleanup.
1916 if (!IsScalar && !CurFuncIsThunk &&
Akira Hatanaka02914dc2018-02-05 20:23:22 +00001917 getContext().isParamDestroyedInCallee(Ty)) {
Akira Hatanaka7275da02018-02-28 07:15:55 +00001918 if (QualType::DestructionKind DtorKind = Ty.isDestructedType()) {
1919 assert((DtorKind == QualType::DK_cxx_destructor ||
1920 DtorKind == QualType::DK_nontrivial_c_struct) &&
1921 "unexpected destructor type");
1922 pushDestroy(DtorKind, DeclPtr, Ty);
1923 }
Reid Kleckner23f4c4b2013-06-21 12:45:15 +00001924 }
Chris Lattner53621a52007-06-13 20:44:40 +00001925 } else {
Gheorghe-Teodor Bercead3dcf2f2018-03-14 14:17:45 +00001926 // Check if the parameter address is controlled by OpenMP runtime.
1927 Address OpenMPLocalAddr =
1928 getLangOpts().OpenMP
1929 ? CGM.getOpenMPRuntime().getAddressOfLocalVariable(*this, &D)
1930 : Address::invalid();
1931 if (getLangOpts().OpenMP && OpenMPLocalAddr.isValid()) {
1932 DeclPtr = OpenMPLocalAddr;
1933 } else {
1934 // Otherwise, create a temporary to hold the value.
1935 DeclPtr = CreateMemTemp(Ty, getContext().getDeclAlign(&D),
1936 D.getName() + ".addr");
1937 }
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001938 DoStore = true;
1939 }
Mike Stump11289f42009-09-09 15:08:12 +00001940
John McCall7f416cc2015-09-08 08:05:57 +00001941 llvm::Value *ArgVal = (DoStore ? Arg.getDirectValue() : nullptr);
1942
1943 LValue lv = MakeAddrLValue(DeclPtr, Ty);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001944 if (IsScalar) {
John McCall31168b02011-06-15 23:02:42 +00001945 Qualifiers qs = Ty.getQualifiers();
John McCall31168b02011-06-15 23:02:42 +00001946 if (Qualifiers::ObjCLifetime lt = qs.getObjCLifetime()) {
1947 // We honor __attribute__((ns_consumed)) for types with lifetime.
1948 // For __strong, it's handled by just skipping the initial retain;
1949 // otherwise we have to balance out the initial +1 with an extra
1950 // cleanup to do the release at the end of the function.
1951 bool isConsumed = D.hasAttr<NSConsumedAttr>();
1952
1953 // 'self' is always formally __strong, but if this is not an
1954 // init method then we don't want to retain it.
John McCalld4631322011-06-17 06:42:21 +00001955 if (D.isARCPseudoStrong()) {
John McCall31168b02011-06-15 23:02:42 +00001956 const ObjCMethodDecl *method = cast<ObjCMethodDecl>(CurCodeDecl);
1957 assert(&D == method->getSelfDecl());
John McCalld4631322011-06-17 06:42:21 +00001958 assert(lt == Qualifiers::OCL_Strong);
1959 assert(qs.hasConst());
John McCall31168b02011-06-15 23:02:42 +00001960 assert(method->getMethodFamily() != OMF_init);
John McCall10123692011-06-15 23:40:09 +00001961 (void) method;
John McCall31168b02011-06-15 23:02:42 +00001962 lt = Qualifiers::OCL_ExplicitNone;
1963 }
1964
Saleem Abdulrasoolda6784e2017-06-27 18:37:51 +00001965 // Load objects passed indirectly.
1966 if (Arg.isIndirect() && !ArgVal)
1967 ArgVal = Builder.CreateLoad(DeclPtr);
1968
John McCall31168b02011-06-15 23:02:42 +00001969 if (lt == Qualifiers::OCL_Strong) {
Fariborz Jahanian134cec62013-02-21 00:40:10 +00001970 if (!isConsumed) {
1971 if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
1972 // use objc_storeStrong(&dest, value) for retaining the
1973 // object. But first, store a null into 'dest' because
1974 // objc_storeStrong attempts to release its old value.
Nick Lewycky2d84e842013-10-02 02:29:49 +00001975 llvm::Value *Null = CGM.EmitNullConstant(D.getType());
Fariborz Jahanian134cec62013-02-21 00:40:10 +00001976 EmitStoreOfScalar(Null, lv, /* isInitialization */ true);
John McCall7f416cc2015-09-08 08:05:57 +00001977 EmitARCStoreStrongCall(lv.getAddress(), ArgVal, true);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001978 DoStore = false;
Fariborz Jahanian134cec62013-02-21 00:40:10 +00001979 }
1980 else
John McCall31168b02011-06-15 23:02:42 +00001981 // Don't use objc_retainBlock for block pointers, because we
1982 // don't want to Block_copy something just because we got it
1983 // as a parameter.
John McCall7f416cc2015-09-08 08:05:57 +00001984 ArgVal = EmitARCRetainNonBlock(ArgVal);
Fariborz Jahanian134cec62013-02-21 00:40:10 +00001985 }
John McCall31168b02011-06-15 23:02:42 +00001986 } else {
1987 // Push the cleanup for a consumed parameter.
John McCallcdda29c2013-03-13 03:10:54 +00001988 if (isConsumed) {
1989 ARCPreciseLifetime_t precise = (D.hasAttr<ObjCPreciseLifetimeAttr>()
1990 ? ARCPreciseLifetime : ARCImpreciseLifetime);
John McCall7f416cc2015-09-08 08:05:57 +00001991 EHStack.pushCleanup<ConsumeARCParameter>(getARCCleanupKind(), ArgVal,
John McCallcdda29c2013-03-13 03:10:54 +00001992 precise);
1993 }
John McCall31168b02011-06-15 23:02:42 +00001994
1995 if (lt == Qualifiers::OCL_Weak) {
John McCall7f416cc2015-09-08 08:05:57 +00001996 EmitARCInitWeak(DeclPtr, ArgVal);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00001997 DoStore = false; // The weak init is a store, no need to do two.
John McCall31168b02011-06-15 23:02:42 +00001998 }
1999 }
2000
2001 // Enter the cleanup scope.
2002 EmitAutoVarWithLifetime(*this, D, DeclPtr, lt);
2003 }
Chris Lattner53621a52007-06-13 20:44:40 +00002004 }
2005
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002006 // Store the initial value into the alloca.
2007 if (DoStore)
John McCall7f416cc2015-09-08 08:05:57 +00002008 EmitStoreOfScalar(ArgVal, lv, /* isInitialization */ true);
Reid Kleckner314ef7b2014-02-01 00:04:45 +00002009
John McCall7f416cc2015-09-08 08:05:57 +00002010 setAddrOfLocalVar(&D, DeclPtr);
Sanjiv Gupta18de6242008-05-30 10:30:31 +00002011
2012 // Emit debug info for param declaration.
Alexey Samsonov74a38682012-05-04 07:39:27 +00002013 if (CGDebugInfo *DI = getDebugInfo()) {
Benjamin Kramer8c305922016-02-02 11:06:51 +00002014 if (CGM.getCodeGenOpts().getDebugInfo() >=
2015 codegenoptions::LimitedDebugInfo) {
John McCall7f416cc2015-09-08 08:05:57 +00002016 DI->EmitDeclareOfArgVariable(&D, DeclPtr.getPointer(), ArgNo, Builder);
Alexey Samsonov74a38682012-05-04 07:39:27 +00002017 }
2018 }
Julien Lerouge5a6b6982011-09-09 22:41:49 +00002019
2020 if (D.hasAttr<AnnotateAttr>())
John McCall7f416cc2015-09-08 08:05:57 +00002021 EmitVarAnnotations(&D, DeclPtr.getPointer());
Vedant Kumar42c17ec2017-03-14 01:56:34 +00002022
2023 // We can only check return value nullability if all arguments to the
2024 // function satisfy their nullability preconditions. This makes it necessary
2025 // to emit null checks for args in the function body itself.
2026 if (requiresReturnValueNullabilityCheck()) {
2027 auto Nullability = Ty->getNullability(getContext());
2028 if (Nullability && *Nullability == NullabilityKind::NonNull) {
2029 SanitizerScope SanScope(this);
2030 RetValNullabilityPrecondition =
2031 Builder.CreateAnd(RetValNullabilityPrecondition,
2032 Builder.CreateIsNotNull(Arg.getAnyValue()));
2033 }
2034 }
Chris Lattner53621a52007-06-13 20:44:40 +00002035}
Alexey Bataev94a4f0c2016-03-03 05:21:39 +00002036
Alexey Bataevc5b1d322016-03-04 09:22:22 +00002037void CodeGenModule::EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D,
2038 CodeGenFunction *CGF) {
2039 if (!LangOpts.OpenMP || (!LangOpts.EmitAllDecls && !D->isUsed()))
2040 return;
2041 getOpenMPRuntime().emitUserDefinedReduction(CGF, D);
2042}