1 //===--- CGDecl.cpp - Emit LLVM Code for declarations ---------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This contains code to emit Decl nodes as LLVM code.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "CGBlocks.h"
15 #include "CGCXXABI.h"
16 #include "CGCleanup.h"
17 #include "CGDebugInfo.h"
18 #include "CGOpenCLRuntime.h"
19 #include "CGOpenMPRuntime.h"
20 #include "CodeGenFunction.h"
21 #include "CodeGenModule.h"
22 #include "ConstantEmitter.h"
23 #include "TargetInfo.h"
24 #include "clang/AST/ASTContext.h"
25 #include "clang/AST/CharUnits.h"
26 #include "clang/AST/Decl.h"
27 #include "clang/AST/DeclObjC.h"
28 #include "clang/AST/DeclOpenMP.h"
29 #include "clang/Basic/SourceManager.h"
30 #include "clang/Basic/TargetInfo.h"
31 #include "clang/CodeGen/CGFunctionInfo.h"
32 #include "clang/Frontend/CodeGenOptions.h"
33 #include "llvm/IR/DataLayout.h"
34 #include "llvm/IR/GlobalVariable.h"
35 #include "llvm/IR/Intrinsics.h"
36 #include "llvm/IR/Type.h"
37
38 using namespace clang;
39 using namespace CodeGen;
40
EmitDecl(const Decl & D)41 void CodeGenFunction::EmitDecl(const Decl &D) {
42 switch (D.getKind()) {
43 case Decl::BuiltinTemplate:
44 case Decl::TranslationUnit:
45 case Decl::ExternCContext:
46 case Decl::Namespace:
47 case Decl::UnresolvedUsingTypename:
48 case Decl::ClassTemplateSpecialization:
49 case Decl::ClassTemplatePartialSpecialization:
50 case Decl::VarTemplateSpecialization:
51 case Decl::VarTemplatePartialSpecialization:
52 case Decl::TemplateTypeParm:
53 case Decl::UnresolvedUsingValue:
54 case Decl::NonTypeTemplateParm:
55 case Decl::CXXDeductionGuide:
56 case Decl::CXXMethod:
57 case Decl::CXXConstructor:
58 case Decl::CXXDestructor:
59 case Decl::CXXConversion:
60 case Decl::Field:
61 case Decl::MSProperty:
62 case Decl::IndirectField:
63 case Decl::ObjCIvar:
64 case Decl::ObjCAtDefsField:
65 case Decl::ParmVar:
66 case Decl::ImplicitParam:
67 case Decl::ClassTemplate:
68 case Decl::VarTemplate:
69 case Decl::FunctionTemplate:
70 case Decl::TypeAliasTemplate:
71 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:
80 case Decl::PragmaComment:
81 case Decl::PragmaDetectMismatch:
82 case Decl::AccessSpec:
83 case Decl::LinkageSpec:
84 case Decl::Export:
85 case Decl::ObjCPropertyImpl:
86 case Decl::FileScopeAsm:
87 case Decl::Friend:
88 case Decl::FriendTemplate:
89 case Decl::Block:
90 case Decl::Captured:
91 case Decl::ClassScopeFunctionSpecialization:
92 case Decl::UsingShadow:
93 case Decl::ConstructorUsingShadow:
94 case Decl::ObjCTypeParam:
95 case Decl::Binding:
96 llvm_unreachable("Declaration should not be in declstmts!");
97 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++]
102 case Decl::StaticAssert: // static_assert(X, ""); [C++0x]
103 case Decl::Label: // __label__ x;
104 case Decl::Import:
105 case Decl::OMPThreadPrivate:
106 case Decl::OMPCapturedExpr:
107 case Decl::Empty:
108 // None of these decls require codegen support.
109 return;
110
111 case Decl::NamespaceAlias:
112 if (CGDebugInfo *DI = getDebugInfo())
113 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(D));
114 return;
115 case Decl::Using: // using X; [C++]
116 if (CGDebugInfo *DI = getDebugInfo())
117 DI->EmitUsingDecl(cast<UsingDecl>(D));
118 return;
119 case Decl::UsingPack:
120 for (auto *Using : cast<UsingPackDecl>(D).expansions())
121 EmitDecl(*Using);
122 return;
123 case Decl::UsingDirective: // using namespace X; [C++]
124 if (CGDebugInfo *DI = getDebugInfo())
125 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(D));
126 return;
127 case Decl::Var:
128 case Decl::Decomposition: {
129 const VarDecl &VD = cast<VarDecl>(D);
130 assert(VD.isLocalVarDecl() &&
131 "Should not see file-scope variables inside a function!");
132 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;
138 }
139
140 case Decl::OMPDeclareReduction:
141 return CGM.EmitOMPDeclareReduction(cast<OMPDeclareReductionDecl>(&D), this);
142
143 case Decl::Typedef: // typedef int X;
144 case Decl::TypeAlias: { // using X = int; [C++0x]
145 const TypedefNameDecl &TD = cast<TypedefNameDecl>(D);
146 QualType Ty = TD.getUnderlyingType();
147
148 if (Ty->isVariablyModifiedType())
149 EmitVariablyModifiedType(Ty);
150 }
151 }
152 }
153
154 /// EmitVarDecl - This method handles emission of any variable declaration
155 /// inside a function, including static vars etc.
EmitVarDecl(const VarDecl & D)156 void CodeGenFunction::EmitVarDecl(const VarDecl &D) {
157 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) {
165 // Static sampler variables translated to function calls.
166 if (D.getType()->isSamplerT())
167 return;
168
169 llvm::GlobalValue::LinkageTypes Linkage =
170 CGM.getLLVMLinkageVarDefinition(&D, /*isConstant=*/false);
171
172 // 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.
175
176 return EmitStaticVarDecl(D, Linkage);
177 }
178
179 if (D.getType().getAddressSpace() == LangAS::opencl_local)
180 return CGM.getOpenCLRuntime().EmitWorkGroupLocalVarDecl(*this, D);
181
182 assert(D.hasLocalStorage());
183 return EmitAutoVarDecl(D);
184 }
185
getStaticDeclName(CodeGenModule & CGM,const VarDecl & D)186 static std::string getStaticDeclName(CodeGenModule &CGM, const VarDecl &D) {
187 if (CGM.getLangOpts().CPlusPlus)
188 return CGM.getMangledName(&D).str();
189
190 // 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();
194 if (auto *CD = dyn_cast<CapturedDecl>(DC))
195 DC = cast<DeclContext>(CD->getNonClosureContext());
196 if (const auto *FD = dyn_cast<FunctionDecl>(DC))
197 ContextName = CGM.getMangledName(FD);
198 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();
202 else
203 llvm_unreachable("Unknown context for static var decl");
204
205 ContextName += "." + D.getNameAsString();
206 return ContextName;
207 }
208
getOrCreateStaticVarDecl(const VarDecl & D,llvm::GlobalValue::LinkageTypes Linkage)209 llvm::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
218 QualType Ty = D.getType();
219 assert(Ty->isConstantSizeType() && "VLAs can't be static");
220
221 // Use the label if the variable is renamed with the asm-label extension.
222 std::string Name;
223 if (D.hasAttr<AsmLabelAttr>())
224 Name = getMangledName(&D);
225 else
226 Name = getStaticDeclName(*this, D);
227
228 llvm::Type *LTy = getTypes().ConvertTypeForMem(Ty);
229 LangAS AS = GetGlobalVarAddressSpace(&D);
230 unsigned TargetAS = getContext().getTargetAddressSpace(AS);
231
232 // OpenCL variables in local address space and CUDA shared
233 // variables cannot have an initializer.
234 llvm::Constant *Init = nullptr;
235 if (Ty.getAddressSpace() == LangAS::opencl_local ||
236 D.hasAttr<CUDASharedAttr>())
237 Init = llvm::UndefValue::get(LTy);
238 else
239 Init = EmitNullConstant(Ty);
240
241 llvm::GlobalVariable *GV = new llvm::GlobalVariable(
242 getModule(), LTy, Ty.isConstant(getContext()), Linkage, Init, Name,
243 nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
244 GV->setAlignment(getContext().getDeclAlign(&D).getQuantity());
245
246 if (supportsCOMDAT() && GV->isWeakForLinker())
247 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
248
249 if (D.getTLSKind())
250 setTLSMode(GV, D);
251
252 setGVProperties(GV, &D);
253
254 // Make sure the result is of the correct type.
255 LangAS ExpectedAS = Ty.getAddressSpace();
256 llvm::Constant *Addr = GV;
257 if (AS != ExpectedAS) {
258 Addr = getTargetCodeGenInfo().performAddrSpaceCast(
259 *this, GV, AS, ExpectedAS,
260 LTy->getPointerTo(getContext().getTargetAddressSpace(ExpectedAS)));
261 }
262
263 setStaticLocalDeclAddress(&D, Addr);
264
265 // Ensure that the static local gets initialized by making sure the parent
266 // function gets emitted eventually.
267 const Decl *DC = cast<Decl>(D.getDeclContext());
268
269 // We can't name blocks or captured statements directly, so try to emit their
270 // parents.
271 if (isa<BlockDecl>(DC) || isa<CapturedDecl>(DC)) {
272 DC = DC->getNonClosureContext();
273 // FIXME: Ensure that global blocks get emitted.
274 if (!DC)
275 return Addr;
276 }
277
278 GlobalDecl GD;
279 if (const auto *CD = dyn_cast<CXXConstructorDecl>(DC))
280 GD = GlobalDecl(CD, Ctor_Base);
281 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(DC))
282 GD = GlobalDecl(DD, Dtor_Base);
283 else if (const auto *FD = dyn_cast<FunctionDecl>(DC))
284 GD = GlobalDecl(FD);
285 else {
286 // Don't do anything for Obj-C method decls or global closures. We should
287 // never defer them.
288 assert(isa<ObjCMethodDecl>(DC) && "unexpected parent code decl");
289 }
290 if (GD.getDecl()) {
291 // Disable emission of the parent function for the OpenMP device codegen.
292 CGOpenMPRuntime::DisableAutoDeclareTargetRAII NoDeclTarget(*this);
293 (void)GetAddrOfGlobal(GD);
294 }
295
296 return Addr;
297 }
298
299 /// hasNontrivialDestruction - Determine whether a type's destruction is
300 /// non-trivial. If so, and the variable uses static initialization, we must
301 /// register its destructor to run on exit.
hasNontrivialDestruction(QualType T)302 static bool hasNontrivialDestruction(QualType T) {
303 CXXRecordDecl *RD = T->getBaseElementTypeUnsafe()->getAsCXXRecordDecl();
304 return RD && !RD->hasTrivialDestructor();
305 }
306
307 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
308 /// global variable that has already been created for it. If the initializer
309 /// has a different type than GV does, this may free GV and return a different
310 /// one. Otherwise it just returns GV.
311 llvm::GlobalVariable *
AddInitializerToStaticVarDecl(const VarDecl & D,llvm::GlobalVariable * GV)312 CodeGenFunction::AddInitializerToStaticVarDecl(const VarDecl &D,
313 llvm::GlobalVariable *GV) {
314 ConstantEmitter emitter(*this);
315 llvm::Constant *Init = emitter.tryEmitForInitializer(D);
316
317 // If constant emission failed, then this should be a C++ static
318 // initializer.
319 if (!Init) {
320 if (!getLangOpts().CPlusPlus)
321 CGM.ErrorUnsupported(D.getInit(), "constant l-value expression");
322 else if (HaveInsertPoint()) {
323 // Since we have a static initializer, this global variable can't
324 // be constant.
325 GV->setConstant(false);
326
327 EmitCXXGuardedInit(D, GV, /*PerformInit*/true);
328 }
329 return GV;
330 }
331
332 // The initializer may differ in type from the global. Rewrite
333 // the global to match the initializer. (We have to do this
334 // because some types, like unions, can't be completely represented
335 // in the LLVM type system.)
336 if (GV->getType()->getElementType() != Init->getType()) {
337 llvm::GlobalVariable *OldGV = GV;
338
339 GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(),
340 OldGV->isConstant(),
341 OldGV->getLinkage(), Init, "",
342 /*InsertBefore*/ OldGV,
343 OldGV->getThreadLocalMode(),
344 CGM.getContext().getTargetAddressSpace(D.getType()));
345 GV->setVisibility(OldGV->getVisibility());
346 GV->setDSOLocal(OldGV->isDSOLocal());
347 GV->setComdat(OldGV->getComdat());
348
349 // Steal the name of the old global
350 GV->takeName(OldGV);
351
352 // Replace all uses of the old global with the new global
353 llvm::Constant *NewPtrForOldDecl =
354 llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
355 OldGV->replaceAllUsesWith(NewPtrForOldDecl);
356
357 // Erase the old global, since it is no longer used.
358 OldGV->eraseFromParent();
359 }
360
361 GV->setConstant(CGM.isTypeConstant(D.getType(), true));
362 GV->setInitializer(Init);
363
364 emitter.finalize(GV);
365
366 if (hasNontrivialDestruction(D.getType()) && HaveInsertPoint()) {
367 // We have a constant initializer, but a nontrivial destructor. We still
368 // need to perform a guarded "initialization" in order to register the
369 // destructor.
370 EmitCXXGuardedInit(D, GV, /*PerformInit*/false);
371 }
372
373 return GV;
374 }
375
EmitStaticVarDecl(const VarDecl & D,llvm::GlobalValue::LinkageTypes Linkage)376 void CodeGenFunction::EmitStaticVarDecl(const VarDecl &D,
377 llvm::GlobalValue::LinkageTypes Linkage) {
378 // Check to see if we already have a global variable for this
379 // declaration. This can happen when double-emitting function
380 // bodies, e.g. with complete and base constructors.
381 llvm::Constant *addr = CGM.getOrCreateStaticVarDecl(D, Linkage);
382 CharUnits alignment = getContext().getDeclAlign(&D);
383
384 // Store into LocalDeclMap before generating initializer to handle
385 // circular references.
386 setAddrOfLocalVar(&D, Address(addr, alignment));
387
388 // We can't have a VLA here, but we can have a pointer to a VLA,
389 // even though that doesn't really make any sense.
390 // Make sure to evaluate VLA bounds now so that we have them for later.
391 if (D.getType()->isVariablyModifiedType())
392 EmitVariablyModifiedType(D.getType());
393
394 // Save the type in case adding the initializer forces a type change.
395 llvm::Type *expectedType = addr->getType();
396
397 llvm::GlobalVariable *var =
398 cast<llvm::GlobalVariable>(addr->stripPointerCasts());
399
400 // CUDA's local and local static __shared__ variables should not
401 // have any non-empty initializers. This is ensured by Sema.
402 // Whatever initializer such variable may have when it gets here is
403 // a no-op and should not be emitted.
404 bool isCudaSharedVar = getLangOpts().CUDA && getLangOpts().CUDAIsDevice &&
405 D.hasAttr<CUDASharedAttr>();
406 // If this value has an initializer, emit it.
407 if (D.getInit() && !isCudaSharedVar)
408 var = AddInitializerToStaticVarDecl(D, var);
409
410 var->setAlignment(alignment.getQuantity());
411
412 if (D.hasAttr<AnnotateAttr>())
413 CGM.AddGlobalAnnotations(&D, var);
414
415 if (auto *SA = D.getAttr<PragmaClangBSSSectionAttr>())
416 var->addAttribute("bss-section", SA->getName());
417 if (auto *SA = D.getAttr<PragmaClangDataSectionAttr>())
418 var->addAttribute("data-section", SA->getName());
419 if (auto *SA = D.getAttr<PragmaClangRodataSectionAttr>())
420 var->addAttribute("rodata-section", SA->getName());
421
422 if (const SectionAttr *SA = D.getAttr<SectionAttr>())
423 var->setSection(SA->getName());
424
425 if (D.hasAttr<UsedAttr>())
426 CGM.addUsedGlobal(var);
427
428 // We may have to cast the constant because of the initializer
429 // mismatch above.
430 //
431 // FIXME: It is really dangerous to store this in the map; if anyone
432 // RAUW's the GV uses of this constant will be invalid.
433 llvm::Constant *castedAddr =
434 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(var, expectedType);
435 if (var != castedAddr)
436 LocalDeclMap.find(&D)->second = Address(castedAddr, alignment);
437 CGM.setStaticLocalDeclAddress(&D, castedAddr);
438
439 CGM.getSanitizerMetadata()->reportGlobalToASan(var, D);
440
441 // Emit global variable debug descriptor for static vars.
442 CGDebugInfo *DI = getDebugInfo();
443 if (DI &&
444 CGM.getCodeGenOpts().getDebugInfo() >= codegenoptions::LimitedDebugInfo) {
445 DI->setLocation(D.getLocation());
446 DI->EmitGlobalVariable(var, &D);
447 }
448 }
449
450 namespace {
451 struct DestroyObject final : EHScopeStack::Cleanup {
DestroyObject__anonef83e6cc0111::DestroyObject452 DestroyObject(Address addr, QualType type,
453 CodeGenFunction::Destroyer *destroyer,
454 bool useEHCleanupForArray)
455 : addr(addr), type(type), destroyer(destroyer),
456 useEHCleanupForArray(useEHCleanupForArray) {}
457
458 Address addr;
459 QualType type;
460 CodeGenFunction::Destroyer *destroyer;
461 bool useEHCleanupForArray;
462
Emit__anonef83e6cc0111::DestroyObject463 void Emit(CodeGenFunction &CGF, Flags flags) override {
464 // Don't use an EH cleanup recursively from an EH cleanup.
465 bool useEHCleanupForArray =
466 flags.isForNormalCleanup() && this->useEHCleanupForArray;
467
468 CGF.emitDestroy(addr, type, destroyer, useEHCleanupForArray);
469 }
470 };
471
472 template <class Derived>
473 struct DestroyNRVOVariable : EHScopeStack::Cleanup {
DestroyNRVOVariable__anonef83e6cc0111::DestroyNRVOVariable474 DestroyNRVOVariable(Address addr, llvm::Value *NRVOFlag)
475 : NRVOFlag(NRVOFlag), Loc(addr) {}
476
477 llvm::Value *NRVOFlag;
478 Address Loc;
479
Emit__anonef83e6cc0111::DestroyNRVOVariable480 void Emit(CodeGenFunction &CGF, Flags flags) override {
481 // Along the exceptions path we always execute the dtor.
482 bool NRVO = flags.isForNormalCleanup() && NRVOFlag;
483
484 llvm::BasicBlock *SkipDtorBB = nullptr;
485 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");
489 llvm::Value *DidNRVO =
490 CGF.Builder.CreateFlagLoad(NRVOFlag, "nrvo.val");
491 CGF.Builder.CreateCondBr(DidNRVO, SkipDtorBB, RunDtorBB);
492 CGF.EmitBlock(RunDtorBB);
493 }
494
495 static_cast<Derived *>(this)->emitDestructorCall(CGF);
496
497 if (NRVO) CGF.EmitBlock(SkipDtorBB);
498 }
499
500 virtual ~DestroyNRVOVariable() = default;
501 };
502
503 struct DestroyNRVOVariableCXX final
504 : DestroyNRVOVariable<DestroyNRVOVariableCXX> {
DestroyNRVOVariableCXX__anonef83e6cc0111::DestroyNRVOVariableCXX505 DestroyNRVOVariableCXX(Address addr, const CXXDestructorDecl *Dtor,
506 llvm::Value *NRVOFlag)
507 : DestroyNRVOVariable<DestroyNRVOVariableCXX>(addr, NRVOFlag),
508 Dtor(Dtor) {}
509
510 const CXXDestructorDecl *Dtor;
511
emitDestructorCall__anonef83e6cc0111::DestroyNRVOVariableCXX512 void emitDestructorCall(CodeGenFunction &CGF) {
513 CGF.EmitCXXDestructorCall(Dtor, Dtor_Complete,
514 /*ForVirtualBase=*/false,
515 /*Delegating=*/false, Loc);
516 }
517 };
518
519 struct DestroyNRVOVariableC final
520 : DestroyNRVOVariable<DestroyNRVOVariableC> {
DestroyNRVOVariableC__anonef83e6cc0111::DestroyNRVOVariableC521 DestroyNRVOVariableC(Address addr, llvm::Value *NRVOFlag, QualType Ty)
522 : DestroyNRVOVariable<DestroyNRVOVariableC>(addr, NRVOFlag), Ty(Ty) {}
523
524 QualType Ty;
525
emitDestructorCall__anonef83e6cc0111::DestroyNRVOVariableC526 void emitDestructorCall(CodeGenFunction &CGF) {
527 CGF.destroyNonTrivialCStruct(CGF, Loc, Ty);
528 }
529 };
530
531 struct CallStackRestore final : EHScopeStack::Cleanup {
532 Address Stack;
CallStackRestore__anonef83e6cc0111::CallStackRestore533 CallStackRestore(Address Stack) : Stack(Stack) {}
Emit__anonef83e6cc0111::CallStackRestore534 void Emit(CodeGenFunction &CGF, Flags flags) override {
535 llvm::Value *V = CGF.Builder.CreateLoad(Stack);
536 llvm::Value *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore);
537 CGF.Builder.CreateCall(F, V);
538 }
539 };
540
541 struct ExtendGCLifetime final : EHScopeStack::Cleanup {
542 const VarDecl &Var;
ExtendGCLifetime__anonef83e6cc0111::ExtendGCLifetime543 ExtendGCLifetime(const VarDecl *var) : Var(*var) {}
544
Emit__anonef83e6cc0111::ExtendGCLifetime545 void Emit(CodeGenFunction &CGF, Flags flags) override {
546 // Compute the address of the local variable, in case it's a
547 // byref or something.
548 DeclRefExpr DRE(const_cast<VarDecl*>(&Var), false,
549 Var.getType(), VK_LValue, SourceLocation());
550 llvm::Value *value = CGF.EmitLoadOfScalar(CGF.EmitDeclRefLValue(&DRE),
551 SourceLocation());
552 CGF.EmitExtendGCLifetime(value);
553 }
554 };
555
556 struct CallCleanupFunction final : EHScopeStack::Cleanup {
557 llvm::Constant *CleanupFn;
558 const CGFunctionInfo &FnInfo;
559 const VarDecl &Var;
560
CallCleanupFunction__anonef83e6cc0111::CallCleanupFunction561 CallCleanupFunction(llvm::Constant *CleanupFn, const CGFunctionInfo *Info,
562 const VarDecl *Var)
563 : CleanupFn(CleanupFn), FnInfo(*Info), Var(*Var) {}
564
Emit__anonef83e6cc0111::CallCleanupFunction565 void Emit(CodeGenFunction &CGF, Flags flags) override {
566 DeclRefExpr DRE(const_cast<VarDecl*>(&Var), false,
567 Var.getType(), VK_LValue, SourceLocation());
568 // Compute the address of the local variable, in case it's a byref
569 // or something.
570 llvm::Value *Addr = CGF.EmitDeclRefLValue(&DRE).getPointer();
571
572 // In some cases, the type of the function argument will be different from
573 // the type of the pointer. An example of this is
574 // void f(void* arg);
575 // __attribute__((cleanup(f))) void *g;
576 //
577 // To fix this we insert a bitcast here.
578 QualType ArgTy = FnInfo.arg_begin()->type;
579 llvm::Value *Arg =
580 CGF.Builder.CreateBitCast(Addr, CGF.ConvertType(ArgTy));
581
582 CallArgList Args;
583 Args.add(RValue::get(Arg),
584 CGF.getContext().getPointerType(Var.getType()));
585 auto Callee = CGCallee::forDirect(CleanupFn);
586 CGF.EmitCall(FnInfo, Callee, ReturnValueSlot(), Args);
587 }
588 };
589 } // end anonymous namespace
590
591 /// EmitAutoVarWithLifetime - Does the setup required for an automatic
592 /// variable with lifetime.
EmitAutoVarWithLifetime(CodeGenFunction & CGF,const VarDecl & var,Address addr,Qualifiers::ObjCLifetime lifetime)593 static void EmitAutoVarWithLifetime(CodeGenFunction &CGF, const VarDecl &var,
594 Address addr,
595 Qualifiers::ObjCLifetime lifetime) {
596 switch (lifetime) {
597 case Qualifiers::OCL_None:
598 llvm_unreachable("present but none");
599
600 case Qualifiers::OCL_ExplicitNone:
601 // nothing to do
602 break;
603
604 case Qualifiers::OCL_Strong: {
605 CodeGenFunction::Destroyer *destroyer =
606 (var.hasAttr<ObjCPreciseLifetimeAttr>()
607 ? CodeGenFunction::destroyARCStrongPrecise
608 : CodeGenFunction::destroyARCStrongImprecise);
609
610 CleanupKind cleanupKind = CGF.getARCCleanupKind();
611 CGF.pushDestroy(cleanupKind, addr, var.getType(), destroyer,
612 cleanupKind & EHCleanup);
613 break;
614 }
615 case Qualifiers::OCL_Autoreleasing:
616 // nothing to do
617 break;
618
619 case Qualifiers::OCL_Weak:
620 // __weak objects always get EH cleanups; otherwise, exceptions
621 // could cause really nasty crashes instead of mere leaks.
622 CGF.pushDestroy(NormalAndEHCleanup, addr, var.getType(),
623 CodeGenFunction::destroyARCWeak,
624 /*useEHCleanup*/ true);
625 break;
626 }
627 }
628
isAccessedBy(const VarDecl & var,const Stmt * s)629 static bool isAccessedBy(const VarDecl &var, const Stmt *s) {
630 if (const Expr *e = dyn_cast<Expr>(s)) {
631 // Skip the most common kinds of expressions that make
632 // hierarchy-walking expensive.
633 s = e = e->IgnoreParenCasts();
634
635 if (const DeclRefExpr *ref = dyn_cast<DeclRefExpr>(e))
636 return (ref->getDecl() == &var);
637 if (const BlockExpr *be = dyn_cast<BlockExpr>(e)) {
638 const BlockDecl *block = be->getBlockDecl();
639 for (const auto &I : block->captures()) {
640 if (I.getVariable() == &var)
641 return true;
642 }
643 }
644 }
645
646 for (const Stmt *SubStmt : s->children())
647 // SubStmt might be null; as in missing decl or conditional of an if-stmt.
648 if (SubStmt && isAccessedBy(var, SubStmt))
649 return true;
650
651 return false;
652 }
653
isAccessedBy(const ValueDecl * decl,const Expr * e)654 static bool isAccessedBy(const ValueDecl *decl, const Expr *e) {
655 if (!decl) return false;
656 if (!isa<VarDecl>(decl)) return false;
657 const VarDecl *var = cast<VarDecl>(decl);
658 return isAccessedBy(*var, e);
659 }
660
tryEmitARCCopyWeakInit(CodeGenFunction & CGF,const LValue & destLV,const Expr * init)661 static bool tryEmitARCCopyWeakInit(CodeGenFunction &CGF,
662 const LValue &destLV, const Expr *init) {
663 bool needsCast = false;
664
665 while (auto castExpr = dyn_cast<CastExpr>(init->IgnoreParens())) {
666 switch (castExpr->getCastKind()) {
667 // Look through casts that don't require representation changes.
668 case CK_NoOp:
669 case CK_BitCast:
670 case CK_BlockPointerToObjCPointerCast:
671 needsCast = true;
672 break;
673
674 // If we find an l-value to r-value cast from a __weak variable,
675 // emit this operation as a copy or move.
676 case CK_LValueToRValue: {
677 const Expr *srcExpr = castExpr->getSubExpr();
678 if (srcExpr->getType().getObjCLifetime() != Qualifiers::OCL_Weak)
679 return false;
680
681 // Emit the source l-value.
682 LValue srcLV = CGF.EmitLValue(srcExpr);
683
684 // Handle a formal type change to avoid asserting.
685 auto srcAddr = srcLV.getAddress();
686 if (needsCast) {
687 srcAddr = CGF.Builder.CreateElementBitCast(srcAddr,
688 destLV.getAddress().getElementType());
689 }
690
691 // If it was an l-value, use objc_copyWeak.
692 if (srcExpr->getValueKind() == VK_LValue) {
693 CGF.EmitARCCopyWeak(destLV.getAddress(), srcAddr);
694 } else {
695 assert(srcExpr->getValueKind() == VK_XValue);
696 CGF.EmitARCMoveWeak(destLV.getAddress(), srcAddr);
697 }
698 return true;
699 }
700
701 // Stop at anything else.
702 default:
703 return false;
704 }
705
706 init = castExpr->getSubExpr();
707 }
708 return false;
709 }
710
drillIntoBlockVariable(CodeGenFunction & CGF,LValue & lvalue,const VarDecl * var)711 static void drillIntoBlockVariable(CodeGenFunction &CGF,
712 LValue &lvalue,
713 const VarDecl *var) {
714 lvalue.setAddress(CGF.emitBlockByrefAddress(lvalue.getAddress(), var));
715 }
716
EmitNullabilityCheck(LValue LHS,llvm::Value * RHS,SourceLocation Loc)717 void CodeGenFunction::EmitNullabilityCheck(LValue LHS, llvm::Value *RHS,
718 SourceLocation Loc) {
719 if (!SanOpts.has(SanitizerKind::NullabilityAssign))
720 return;
721
722 auto Nullability = LHS.getType()->getNullability(getContext());
723 if (!Nullability || *Nullability != NullabilityKind::NonNull)
724 return;
725
726 // Check if the right hand side of the assignment is nonnull, if the left
727 // hand side must be nonnull.
728 SanitizerScope SanScope(this);
729 llvm::Value *IsNotNull = Builder.CreateIsNotNull(RHS);
730 llvm::Constant *StaticData[] = {
731 EmitCheckSourceLocation(Loc), EmitCheckTypeDescriptor(LHS.getType()),
732 llvm::ConstantInt::get(Int8Ty, 0), // The LogAlignment info is unused.
733 llvm::ConstantInt::get(Int8Ty, TCK_NonnullAssign)};
734 EmitCheck({{IsNotNull, SanitizerKind::NullabilityAssign}},
735 SanitizerHandler::TypeMismatch, StaticData, RHS);
736 }
737
EmitScalarInit(const Expr * init,const ValueDecl * D,LValue lvalue,bool capturedByInit)738 void CodeGenFunction::EmitScalarInit(const Expr *init, const ValueDecl *D,
739 LValue lvalue, bool capturedByInit) {
740 Qualifiers::ObjCLifetime lifetime = lvalue.getObjCLifetime();
741 if (!lifetime) {
742 llvm::Value *value = EmitScalarExpr(init);
743 if (capturedByInit)
744 drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
745 EmitNullabilityCheck(lvalue, value, init->getExprLoc());
746 EmitStoreThroughLValue(RValue::get(value), lvalue, true);
747 return;
748 }
749
750 if (const CXXDefaultInitExpr *DIE = dyn_cast<CXXDefaultInitExpr>(init))
751 init = DIE->getExpr();
752
753 // If we're emitting a value with lifetime, we have to do the
754 // initialization *before* we leave the cleanup scopes.
755 if (const ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(init)) {
756 enterFullExpression(ewc);
757 init = ewc->getSubExpr();
758 }
759 CodeGenFunction::RunCleanupsScope Scope(*this);
760
761 // We have to maintain the illusion that the variable is
762 // zero-initialized. If the variable might be accessed in its
763 // initializer, zero-initialize before running the initializer, then
764 // actually perform the initialization with an assign.
765 bool accessedByInit = false;
766 if (lifetime != Qualifiers::OCL_ExplicitNone)
767 accessedByInit = (capturedByInit || isAccessedBy(D, init));
768 if (accessedByInit) {
769 LValue tempLV = lvalue;
770 // Drill down to the __block object if necessary.
771 if (capturedByInit) {
772 // We can use a simple GEP for this because it can't have been
773 // moved yet.
774 tempLV.setAddress(emitBlockByrefAddress(tempLV.getAddress(),
775 cast<VarDecl>(D),
776 /*follow*/ false));
777 }
778
779 auto ty = cast<llvm::PointerType>(tempLV.getAddress().getElementType());
780 llvm::Value *zero = CGM.getNullPointer(ty, tempLV.getType());
781
782 // If __weak, we want to use a barrier under certain conditions.
783 if (lifetime == Qualifiers::OCL_Weak)
784 EmitARCInitWeak(tempLV.getAddress(), zero);
785
786 // Otherwise just do a simple store.
787 else
788 EmitStoreOfScalar(zero, tempLV, /* isInitialization */ true);
789 }
790
791 // Emit the initializer.
792 llvm::Value *value = nullptr;
793
794 switch (lifetime) {
795 case Qualifiers::OCL_None:
796 llvm_unreachable("present but none");
797
798 case Qualifiers::OCL_ExplicitNone:
799 value = EmitARCUnsafeUnretainedScalarExpr(init);
800 break;
801
802 case Qualifiers::OCL_Strong: {
803 value = EmitARCRetainScalarExpr(init);
804 break;
805 }
806
807 case Qualifiers::OCL_Weak: {
808 // If it's not accessed by the initializer, try to emit the
809 // initialization with a copy or move.
810 if (!accessedByInit && tryEmitARCCopyWeakInit(*this, lvalue, init)) {
811 return;
812 }
813
814 // No way to optimize a producing initializer into this. It's not
815 // worth optimizing for, because the value will immediately
816 // disappear in the common case.
817 value = EmitScalarExpr(init);
818
819 if (capturedByInit) drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
820 if (accessedByInit)
821 EmitARCStoreWeak(lvalue.getAddress(), value, /*ignored*/ true);
822 else
823 EmitARCInitWeak(lvalue.getAddress(), value);
824 return;
825 }
826
827 case Qualifiers::OCL_Autoreleasing:
828 value = EmitARCRetainAutoreleaseScalarExpr(init);
829 break;
830 }
831
832 if (capturedByInit) drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
833
834 EmitNullabilityCheck(lvalue, value, init->getExprLoc());
835
836 // If the variable might have been accessed by its initializer, we
837 // might have to initialize with a barrier. We have to do this for
838 // both __weak and __strong, but __weak got filtered out above.
839 if (accessedByInit && lifetime == Qualifiers::OCL_Strong) {
840 llvm::Value *oldValue = EmitLoadOfScalar(lvalue, init->getExprLoc());
841 EmitStoreOfScalar(value, lvalue, /* isInitialization */ true);
842 EmitARCRelease(oldValue, ARCImpreciseLifetime);
843 return;
844 }
845
846 EmitStoreOfScalar(value, lvalue, /* isInitialization */ true);
847 }
848
849 /// Decide whether we can emit the non-zero parts of the specified initializer
850 /// with equal or fewer than NumStores scalar stores.
canEmitInitWithFewStoresAfterBZero(llvm::Constant * Init,unsigned & NumStores)851 static bool canEmitInitWithFewStoresAfterBZero(llvm::Constant *Init,
852 unsigned &NumStores) {
853 // Zero and Undef never requires any extra stores.
854 if (isa<llvm::ConstantAggregateZero>(Init) ||
855 isa<llvm::ConstantPointerNull>(Init) ||
856 isa<llvm::UndefValue>(Init))
857 return true;
858 if (isa<llvm::ConstantInt>(Init) || isa<llvm::ConstantFP>(Init) ||
859 isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
860 isa<llvm::ConstantExpr>(Init))
861 return Init->isNullValue() || NumStores--;
862
863 // See if we can emit each element.
864 if (isa<llvm::ConstantArray>(Init) || isa<llvm::ConstantStruct>(Init)) {
865 for (unsigned i = 0, e = Init->getNumOperands(); i != e; ++i) {
866 llvm::Constant *Elt = cast<llvm::Constant>(Init->getOperand(i));
867 if (!canEmitInitWithFewStoresAfterBZero(Elt, NumStores))
868 return false;
869 }
870 return true;
871 }
872
873 if (llvm::ConstantDataSequential *CDS =
874 dyn_cast<llvm::ConstantDataSequential>(Init)) {
875 for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
876 llvm::Constant *Elt = CDS->getElementAsConstant(i);
877 if (!canEmitInitWithFewStoresAfterBZero(Elt, NumStores))
878 return false;
879 }
880 return true;
881 }
882
883 // Anything else is hard and scary.
884 return false;
885 }
886
887 /// For inits that canEmitInitWithFewStoresAfterBZero returned true for, emit
888 /// the scalar stores that would be required.
emitStoresForInitAfterBZero(CodeGenModule & CGM,llvm::Constant * Init,Address Loc,bool isVolatile,CGBuilderTy & Builder)889 static void emitStoresForInitAfterBZero(CodeGenModule &CGM,
890 llvm::Constant *Init, Address Loc,
891 bool isVolatile, CGBuilderTy &Builder) {
892 assert(!Init->isNullValue() && !isa<llvm::UndefValue>(Init) &&
893 "called emitStoresForInitAfterBZero for zero or undef value.");
894
895 if (isa<llvm::ConstantInt>(Init) || isa<llvm::ConstantFP>(Init) ||
896 isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
897 isa<llvm::ConstantExpr>(Init)) {
898 Builder.CreateStore(Init, Loc, isVolatile);
899 return;
900 }
901
902 if (llvm::ConstantDataSequential *CDS =
903 dyn_cast<llvm::ConstantDataSequential>(Init)) {
904 for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
905 llvm::Constant *Elt = CDS->getElementAsConstant(i);
906
907 // If necessary, get a pointer to the element and emit it.
908 if (!Elt->isNullValue() && !isa<llvm::UndefValue>(Elt))
909 emitStoresForInitAfterBZero(
910 CGM, Elt,
911 Builder.CreateConstInBoundsGEP2_32(Loc, 0, i, CGM.getDataLayout()),
912 isVolatile, Builder);
913 }
914 return;
915 }
916
917 assert((isa<llvm::ConstantStruct>(Init) || isa<llvm::ConstantArray>(Init)) &&
918 "Unknown value type!");
919
920 for (unsigned i = 0, e = Init->getNumOperands(); i != e; ++i) {
921 llvm::Constant *Elt = cast<llvm::Constant>(Init->getOperand(i));
922
923 // If necessary, get a pointer to the element and emit it.
924 if (!Elt->isNullValue() && !isa<llvm::UndefValue>(Elt))
925 emitStoresForInitAfterBZero(
926 CGM, Elt,
927 Builder.CreateConstInBoundsGEP2_32(Loc, 0, i, CGM.getDataLayout()),
928 isVolatile, Builder);
929 }
930 }
931
932 /// Decide whether we should use bzero plus some stores to initialize a local
933 /// variable instead of using a memcpy from a constant global. It is beneficial
934 /// to use bzero if the global is all zeros, or mostly zeros and large.
shouldUseBZeroPlusStoresToInitialize(llvm::Constant * Init,uint64_t GlobalSize)935 static bool shouldUseBZeroPlusStoresToInitialize(llvm::Constant *Init,
936 uint64_t GlobalSize) {
937 // If a global is all zeros, always use a bzero.
938 if (isa<llvm::ConstantAggregateZero>(Init)) return true;
939
940 // If a non-zero global is <= 32 bytes, always use a memcpy. If it is large,
941 // do it if it will require 6 or fewer scalar stores.
942 // TODO: Should budget depends on the size? Avoiding a large global warrants
943 // plopping in more stores.
944 unsigned StoreBudget = 6;
945 uint64_t SizeLimit = 32;
946
947 return GlobalSize > SizeLimit &&
948 canEmitInitWithFewStoresAfterBZero(Init, StoreBudget);
949 }
950
951 /// A byte pattern.
952 ///
953 /// Can be "any" pattern if the value was padding or known to be undef.
954 /// Can be "none" pattern if a sequence doesn't exist.
955 class BytePattern {
956 uint8_t Val;
957 enum class ValueType : uint8_t { Specific, Any, None } Type;
BytePattern(ValueType Type)958 BytePattern(ValueType Type) : Type(Type) {}
959
960 public:
BytePattern(uint8_t Value)961 BytePattern(uint8_t Value) : Val(Value), Type(ValueType::Specific) {}
Any()962 static BytePattern Any() { return BytePattern(ValueType::Any); }
None()963 static BytePattern None() { return BytePattern(ValueType::None); }
isAny() const964 bool isAny() const { return Type == ValueType::Any; }
isNone() const965 bool isNone() const { return Type == ValueType::None; }
isValued() const966 bool isValued() const { return Type == ValueType::Specific; }
getValue() const967 uint8_t getValue() const {
968 assert(isValued());
969 return Val;
970 }
merge(const BytePattern Other) const971 BytePattern merge(const BytePattern Other) const {
972 if (isNone() || Other.isNone())
973 return None();
974 if (isAny())
975 return Other;
976 if (Other.isAny())
977 return *this;
978 if (getValue() == Other.getValue())
979 return *this;
980 return None();
981 }
982 };
983
984 /// Figures out whether the constant can be initialized with memset.
constantIsRepeatedBytePattern(llvm::Constant * C)985 static BytePattern constantIsRepeatedBytePattern(llvm::Constant *C) {
986 if (isa<llvm::ConstantAggregateZero>(C) || isa<llvm::ConstantPointerNull>(C))
987 return BytePattern(0x00);
988 if (isa<llvm::UndefValue>(C))
989 return BytePattern::Any();
990
991 if (isa<llvm::ConstantInt>(C)) {
992 auto *Int = cast<llvm::ConstantInt>(C);
993 if (Int->getBitWidth() % 8 != 0)
994 return BytePattern::None();
995 const llvm::APInt &Value = Int->getValue();
996 if (Value.isSplat(8))
997 return BytePattern(Value.getLoBits(8).getLimitedValue());
998 return BytePattern::None();
999 }
1000
1001 if (isa<llvm::ConstantFP>(C)) {
1002 auto *FP = cast<llvm::ConstantFP>(C);
1003 llvm::APInt Bits = FP->getValueAPF().bitcastToAPInt();
1004 if (Bits.getBitWidth() % 8 != 0)
1005 return BytePattern::None();
1006 if (!Bits.isSplat(8))
1007 return BytePattern::None();
1008 return BytePattern(Bits.getLimitedValue() & 0xFF);
1009 }
1010
1011 if (isa<llvm::ConstantVector>(C)) {
1012 llvm::Constant *Splat = cast<llvm::ConstantVector>(C)->getSplatValue();
1013 if (Splat)
1014 return constantIsRepeatedBytePattern(Splat);
1015 return BytePattern::None();
1016 }
1017
1018 if (isa<llvm::ConstantArray>(C) || isa<llvm::ConstantStruct>(C)) {
1019 BytePattern Pattern(BytePattern::Any());
1020 for (unsigned I = 0, E = C->getNumOperands(); I != E; ++I) {
1021 llvm::Constant *Elt = cast<llvm::Constant>(C->getOperand(I));
1022 Pattern = Pattern.merge(constantIsRepeatedBytePattern(Elt));
1023 if (Pattern.isNone())
1024 return Pattern;
1025 }
1026 return Pattern;
1027 }
1028
1029 if (llvm::ConstantDataSequential *CDS =
1030 dyn_cast<llvm::ConstantDataSequential>(C)) {
1031 BytePattern Pattern(BytePattern::Any());
1032 for (unsigned I = 0, E = CDS->getNumElements(); I != E; ++I) {
1033 llvm::Constant *Elt = CDS->getElementAsConstant(I);
1034 Pattern = Pattern.merge(constantIsRepeatedBytePattern(Elt));
1035 if (Pattern.isNone())
1036 return Pattern;
1037 }
1038 return Pattern;
1039 }
1040
1041 // BlockAddress, ConstantExpr, and everything else is scary.
1042 return BytePattern::None();
1043 }
1044
1045 /// Decide whether we should use memset to initialize a local variable instead
1046 /// of using a memcpy from a constant global. Assumes we've already decided to
1047 /// not user bzero.
1048 /// FIXME We could be more clever, as we are for bzero above, and generate
1049 /// memset followed by stores. It's unclear that's worth the effort.
shouldUseMemSetToInitialize(llvm::Constant * Init,uint64_t GlobalSize)1050 static BytePattern shouldUseMemSetToInitialize(llvm::Constant *Init,
1051 uint64_t GlobalSize) {
1052 uint64_t SizeLimit = 32;
1053 if (GlobalSize <= SizeLimit)
1054 return BytePattern::None();
1055 return constantIsRepeatedBytePattern(Init);
1056 }
1057
1058 /// EmitAutoVarDecl - Emit code and set up an entry in LocalDeclMap for a
1059 /// variable declaration with auto, register, or no storage class specifier.
1060 /// These turn into simple stack objects, or GlobalValues depending on target.
EmitAutoVarDecl(const VarDecl & D)1061 void CodeGenFunction::EmitAutoVarDecl(const VarDecl &D) {
1062 AutoVarEmission emission = EmitAutoVarAlloca(D);
1063 EmitAutoVarInit(emission);
1064 EmitAutoVarCleanups(emission);
1065 }
1066
1067 /// Emit a lifetime.begin marker if some criteria are satisfied.
1068 /// \return a pointer to the temporary size Value if a marker was emitted, null
1069 /// otherwise
EmitLifetimeStart(uint64_t Size,llvm::Value * Addr)1070 llvm::Value *CodeGenFunction::EmitLifetimeStart(uint64_t Size,
1071 llvm::Value *Addr) {
1072 if (!ShouldEmitLifetimeMarkers)
1073 return nullptr;
1074
1075 assert(Addr->getType()->getPointerAddressSpace() ==
1076 CGM.getDataLayout().getAllocaAddrSpace() &&
1077 "Pointer should be in alloca address space");
1078 llvm::Value *SizeV = llvm::ConstantInt::get(Int64Ty, Size);
1079 Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
1080 llvm::CallInst *C =
1081 Builder.CreateCall(CGM.getLLVMLifetimeStartFn(), {SizeV, Addr});
1082 C->setDoesNotThrow();
1083 return SizeV;
1084 }
1085
EmitLifetimeEnd(llvm::Value * Size,llvm::Value * Addr)1086 void CodeGenFunction::EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr) {
1087 assert(Addr->getType()->getPointerAddressSpace() ==
1088 CGM.getDataLayout().getAllocaAddrSpace() &&
1089 "Pointer should be in alloca address space");
1090 Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
1091 llvm::CallInst *C =
1092 Builder.CreateCall(CGM.getLLVMLifetimeEndFn(), {Size, Addr});
1093 C->setDoesNotThrow();
1094 }
1095
EmitAndRegisterVariableArrayDimensions(CGDebugInfo * DI,const VarDecl & D,bool EmitDebugInfo)1096 void CodeGenFunction::EmitAndRegisterVariableArrayDimensions(
1097 CGDebugInfo *DI, const VarDecl &D, bool EmitDebugInfo) {
1098 // For each dimension stores its QualType and corresponding
1099 // size-expression Value.
1100 SmallVector<CodeGenFunction::VlaSizePair, 4> Dimensions;
1101
1102 // Break down the array into individual dimensions.
1103 QualType Type1D = D.getType();
1104 while (getContext().getAsVariableArrayType(Type1D)) {
1105 auto VlaSize = getVLAElements1D(Type1D);
1106 if (auto *C = dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))
1107 Dimensions.emplace_back(C, Type1D.getUnqualifiedType());
1108 else {
1109 auto SizeExprAddr = CreateDefaultAlignTempAlloca(
1110 VlaSize.NumElts->getType(), "__vla_expr");
1111 Builder.CreateStore(VlaSize.NumElts, SizeExprAddr);
1112 Dimensions.emplace_back(SizeExprAddr.getPointer(),
1113 Type1D.getUnqualifiedType());
1114 }
1115 Type1D = VlaSize.Type;
1116 }
1117
1118 if (!EmitDebugInfo)
1119 return;
1120
1121 // Register each dimension's size-expression with a DILocalVariable,
1122 // so that it can be used by CGDebugInfo when instantiating a DISubrange
1123 // to describe this array.
1124 for (auto &VlaSize : Dimensions) {
1125 llvm::Metadata *MD;
1126 if (auto *C = dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))
1127 MD = llvm::ConstantAsMetadata::get(C);
1128 else {
1129 // Create an artificial VarDecl to generate debug info for.
1130 IdentifierInfo &NameIdent = getContext().Idents.getOwn(
1131 cast<llvm::AllocaInst>(VlaSize.NumElts)->getName());
1132 auto VlaExprTy = VlaSize.NumElts->getType()->getPointerElementType();
1133 auto QT = getContext().getIntTypeForBitwidth(
1134 VlaExprTy->getScalarSizeInBits(), false);
1135 auto *ArtificialDecl = VarDecl::Create(
1136 getContext(), const_cast<DeclContext *>(D.getDeclContext()),
1137 D.getLocation(), D.getLocation(), &NameIdent, QT,
1138 getContext().CreateTypeSourceInfo(QT), SC_Auto);
1139 ArtificialDecl->setImplicit();
1140
1141 MD = DI->EmitDeclareOfAutoVariable(ArtificialDecl, VlaSize.NumElts,
1142 Builder);
1143 }
1144 assert(MD && "No Size expression debug node created");
1145 DI->registerVLASizeExpression(VlaSize.Type, MD);
1146 }
1147 }
1148
1149 /// EmitAutoVarAlloca - Emit the alloca and debug information for a
1150 /// local variable. Does not emit initialization or destruction.
1151 CodeGenFunction::AutoVarEmission
EmitAutoVarAlloca(const VarDecl & D)1152 CodeGenFunction::EmitAutoVarAlloca(const VarDecl &D) {
1153 QualType Ty = D.getType();
1154 assert(
1155 Ty.getAddressSpace() == LangAS::Default ||
1156 (Ty.getAddressSpace() == LangAS::opencl_private && getLangOpts().OpenCL));
1157
1158 AutoVarEmission emission(D);
1159
1160 bool isByRef = D.hasAttr<BlocksAttr>();
1161 emission.IsByRef = isByRef;
1162
1163 CharUnits alignment = getContext().getDeclAlign(&D);
1164
1165 // If the type is variably-modified, emit all the VLA sizes for it.
1166 if (Ty->isVariablyModifiedType())
1167 EmitVariablyModifiedType(Ty);
1168
1169 auto *DI = getDebugInfo();
1170 bool EmitDebugInfo = DI && CGM.getCodeGenOpts().getDebugInfo() >=
1171 codegenoptions::LimitedDebugInfo;
1172
1173 Address address = Address::invalid();
1174 Address AllocaAddr = Address::invalid();
1175 if (Ty->isConstantSizeType()) {
1176 bool NRVO = getLangOpts().ElideConstructors &&
1177 D.isNRVOVariable();
1178
1179 // If this value is an array or struct with a statically determinable
1180 // constant initializer, there are optimizations we can do.
1181 //
1182 // TODO: We should constant-evaluate the initializer of any variable,
1183 // as long as it is initialized by a constant expression. Currently,
1184 // isConstantInitializer produces wrong answers for structs with
1185 // reference or bitfield members, and a few other cases, and checking
1186 // for POD-ness protects us from some of these.
1187 if (D.getInit() && (Ty->isArrayType() || Ty->isRecordType()) &&
1188 (D.isConstexpr() ||
1189 ((Ty.isPODType(getContext()) ||
1190 getContext().getBaseElementType(Ty)->isObjCObjectPointerType()) &&
1191 D.getInit()->isConstantInitializer(getContext(), false)))) {
1192
1193 // If the variable's a const type, and it's neither an NRVO
1194 // candidate nor a __block variable and has no mutable members,
1195 // emit it as a global instead.
1196 // Exception is if a variable is located in non-constant address space
1197 // in OpenCL.
1198 if ((!getLangOpts().OpenCL ||
1199 Ty.getAddressSpace() == LangAS::opencl_constant) &&
1200 (CGM.getCodeGenOpts().MergeAllConstants && !NRVO && !isByRef &&
1201 CGM.isTypeConstant(Ty, true))) {
1202 EmitStaticVarDecl(D, llvm::GlobalValue::InternalLinkage);
1203
1204 // Signal this condition to later callbacks.
1205 emission.Addr = Address::invalid();
1206 assert(emission.wasEmittedAsGlobal());
1207 return emission;
1208 }
1209
1210 // Otherwise, tell the initialization code that we're in this case.
1211 emission.IsConstantAggregate = true;
1212 }
1213
1214 // A normal fixed sized variable becomes an alloca in the entry block,
1215 // unless:
1216 // - it's an NRVO variable.
1217 // - we are compiling OpenMP and it's an OpenMP local variable.
1218
1219 Address OpenMPLocalAddr =
1220 getLangOpts().OpenMP
1221 ? CGM.getOpenMPRuntime().getAddressOfLocalVariable(*this, &D)
1222 : Address::invalid();
1223 if (getLangOpts().OpenMP && OpenMPLocalAddr.isValid()) {
1224 address = OpenMPLocalAddr;
1225 } else if (NRVO) {
1226 // The named return value optimization: allocate this variable in the
1227 // return slot, so that we can elide the copy when returning this
1228 // variable (C++0x [class.copy]p34).
1229 address = ReturnValue;
1230
1231 if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
1232 const auto *RD = RecordTy->getDecl();
1233 const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD);
1234 if ((CXXRD && !CXXRD->hasTrivialDestructor()) ||
1235 RD->isNonTrivialToPrimitiveDestroy()) {
1236 // Create a flag that is used to indicate when the NRVO was applied
1237 // to this variable. Set it to zero to indicate that NRVO was not
1238 // applied.
1239 llvm::Value *Zero = Builder.getFalse();
1240 Address NRVOFlag =
1241 CreateTempAlloca(Zero->getType(), CharUnits::One(), "nrvo");
1242 EnsureInsertPoint();
1243 Builder.CreateStore(Zero, NRVOFlag);
1244
1245 // Record the NRVO flag for this variable.
1246 NRVOFlags[&D] = NRVOFlag.getPointer();
1247 emission.NRVOFlag = NRVOFlag.getPointer();
1248 }
1249 }
1250 } else {
1251 CharUnits allocaAlignment;
1252 llvm::Type *allocaTy;
1253 if (isByRef) {
1254 auto &byrefInfo = getBlockByrefInfo(&D);
1255 allocaTy = byrefInfo.Type;
1256 allocaAlignment = byrefInfo.ByrefAlignment;
1257 } else {
1258 allocaTy = ConvertTypeForMem(Ty);
1259 allocaAlignment = alignment;
1260 }
1261
1262 // Create the alloca. Note that we set the name separately from
1263 // building the instruction so that it's there even in no-asserts
1264 // builds.
1265 address = CreateTempAlloca(allocaTy, allocaAlignment, D.getName(),
1266 /*ArraySize=*/nullptr, &AllocaAddr);
1267
1268 // Don't emit lifetime markers for MSVC catch parameters. The lifetime of
1269 // the catch parameter starts in the catchpad instruction, and we can't
1270 // insert code in those basic blocks.
1271 bool IsMSCatchParam =
1272 D.isExceptionVariable() && getTarget().getCXXABI().isMicrosoft();
1273
1274 // Emit a lifetime intrinsic if meaningful. There's no point in doing this
1275 // if we don't have a valid insertion point (?).
1276 if (HaveInsertPoint() && !IsMSCatchParam) {
1277 // If there's a jump into the lifetime of this variable, its lifetime
1278 // gets broken up into several regions in IR, which requires more work
1279 // to handle correctly. For now, just omit the intrinsics; this is a
1280 // rare case, and it's better to just be conservatively correct.
1281 // PR28267.
1282 //
1283 // We have to do this in all language modes if there's a jump past the
1284 // declaration. We also have to do it in C if there's a jump to an
1285 // earlier point in the current block because non-VLA lifetimes begin as
1286 // soon as the containing block is entered, not when its variables
1287 // actually come into scope; suppressing the lifetime annotations
1288 // completely in this case is unnecessarily pessimistic, but again, this
1289 // is rare.
1290 if (!Bypasses.IsBypassed(&D) &&
1291 !(!getLangOpts().CPlusPlus && hasLabelBeenSeenInCurrentScope())) {
1292 uint64_t size = CGM.getDataLayout().getTypeAllocSize(allocaTy);
1293 emission.SizeForLifetimeMarkers =
1294 EmitLifetimeStart(size, AllocaAddr.getPointer());
1295 }
1296 } else {
1297 assert(!emission.useLifetimeMarkers());
1298 }
1299 }
1300 } else {
1301 EnsureInsertPoint();
1302
1303 if (!DidCallStackSave) {
1304 // Save the stack.
1305 Address Stack =
1306 CreateTempAlloca(Int8PtrTy, getPointerAlign(), "saved_stack");
1307
1308 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::stacksave);
1309 llvm::Value *V = Builder.CreateCall(F);
1310 Builder.CreateStore(V, Stack);
1311
1312 DidCallStackSave = true;
1313
1314 // Push a cleanup block and restore the stack there.
1315 // FIXME: in general circumstances, this should be an EH cleanup.
1316 pushStackRestore(NormalCleanup, Stack);
1317 }
1318
1319 auto VlaSize = getVLASize(Ty);
1320 llvm::Type *llvmTy = ConvertTypeForMem(VlaSize.Type);
1321
1322 // Allocate memory for the array.
1323 address = CreateTempAlloca(llvmTy, alignment, "vla", VlaSize.NumElts,
1324 &AllocaAddr);
1325
1326 // If we have debug info enabled, properly describe the VLA dimensions for
1327 // this type by registering the vla size expression for each of the
1328 // dimensions.
1329 EmitAndRegisterVariableArrayDimensions(DI, D, EmitDebugInfo);
1330 }
1331
1332 setAddrOfLocalVar(&D, address);
1333 emission.Addr = address;
1334 emission.AllocaAddr = AllocaAddr;
1335
1336 // Emit debug info for local var declaration.
1337 if (EmitDebugInfo && HaveInsertPoint()) {
1338 DI->setLocation(D.getLocation());
1339 (void)DI->EmitDeclareOfAutoVariable(&D, address.getPointer(), Builder);
1340 }
1341
1342 if (D.hasAttr<AnnotateAttr>())
1343 EmitVarAnnotations(&D, address.getPointer());
1344
1345 // Make sure we call @llvm.lifetime.end.
1346 if (emission.useLifetimeMarkers())
1347 EHStack.pushCleanup<CallLifetimeEnd>(NormalEHLifetimeMarker,
1348 emission.getOriginalAllocatedAddress(),
1349 emission.getSizeForLifetimeMarkers());
1350
1351 return emission;
1352 }
1353
1354 static bool isCapturedBy(const VarDecl &, const Expr *);
1355
1356 /// Determines whether the given __block variable is potentially
1357 /// captured by the given statement.
isCapturedBy(const VarDecl & Var,const Stmt * S)1358 static bool isCapturedBy(const VarDecl &Var, const Stmt *S) {
1359 if (const Expr *E = dyn_cast<Expr>(S))
1360 return isCapturedBy(Var, E);
1361 for (const Stmt *SubStmt : S->children())
1362 if (isCapturedBy(Var, SubStmt))
1363 return true;
1364 return false;
1365 }
1366
1367 /// Determines whether the given __block variable is potentially
1368 /// captured by the given expression.
isCapturedBy(const VarDecl & Var,const Expr * E)1369 static bool isCapturedBy(const VarDecl &Var, const Expr *E) {
1370 // Skip the most common kinds of expressions that make
1371 // hierarchy-walking expensive.
1372 E = E->IgnoreParenCasts();
1373
1374 if (const BlockExpr *BE = dyn_cast<BlockExpr>(E)) {
1375 const BlockDecl *Block = BE->getBlockDecl();
1376 for (const auto &I : Block->captures()) {
1377 if (I.getVariable() == &Var)
1378 return true;
1379 }
1380
1381 // No need to walk into the subexpressions.
1382 return false;
1383 }
1384
1385 if (const StmtExpr *SE = dyn_cast<StmtExpr>(E)) {
1386 const CompoundStmt *CS = SE->getSubStmt();
1387 for (const auto *BI : CS->body())
1388 if (const auto *BIE = dyn_cast<Expr>(BI)) {
1389 if (isCapturedBy(Var, BIE))
1390 return true;
1391 }
1392 else if (const auto *DS = dyn_cast<DeclStmt>(BI)) {
1393 // special case declarations
1394 for (const auto *I : DS->decls()) {
1395 if (const auto *VD = dyn_cast<VarDecl>((I))) {
1396 const Expr *Init = VD->getInit();
1397 if (Init && isCapturedBy(Var, Init))
1398 return true;
1399 }
1400 }
1401 }
1402 else
1403 // FIXME. Make safe assumption assuming arbitrary statements cause capturing.
1404 // Later, provide code to poke into statements for capture analysis.
1405 return true;
1406 return false;
1407 }
1408
1409 for (const Stmt *SubStmt : E->children())
1410 if (isCapturedBy(Var, SubStmt))
1411 return true;
1412
1413 return false;
1414 }
1415
1416 /// Determine whether the given initializer is trivial in the sense
1417 /// that it requires no code to be generated.
isTrivialInitializer(const Expr * Init)1418 bool CodeGenFunction::isTrivialInitializer(const Expr *Init) {
1419 if (!Init)
1420 return true;
1421
1422 if (const CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init))
1423 if (CXXConstructorDecl *Constructor = Construct->getConstructor())
1424 if (Constructor->isTrivial() &&
1425 Constructor->isDefaultConstructor() &&
1426 !Construct->requiresZeroInitialization())
1427 return true;
1428
1429 return false;
1430 }
1431
EmitAutoVarInit(const AutoVarEmission & emission)1432 void CodeGenFunction::EmitAutoVarInit(const AutoVarEmission &emission) {
1433 assert(emission.Variable && "emission was not valid!");
1434
1435 // If this was emitted as a global constant, we're done.
1436 if (emission.wasEmittedAsGlobal()) return;
1437
1438 const VarDecl &D = *emission.Variable;
1439 auto DL = ApplyDebugLocation::CreateDefaultArtificial(*this, D.getLocation());
1440 QualType type = D.getType();
1441
1442 // If this local has an initializer, emit it now.
1443 const Expr *Init = D.getInit();
1444
1445 // If we are at an unreachable point, we don't need to emit the initializer
1446 // unless it contains a label.
1447 if (!HaveInsertPoint()) {
1448 if (!Init || !ContainsLabel(Init)) return;
1449 EnsureInsertPoint();
1450 }
1451
1452 // Initialize the structure of a __block variable.
1453 if (emission.IsByRef)
1454 emitByrefStructureInit(emission);
1455
1456 // Initialize the variable here if it doesn't have a initializer and it is a
1457 // C struct that is non-trivial to initialize or an array containing such a
1458 // struct.
1459 if (!Init &&
1460 type.isNonTrivialToPrimitiveDefaultInitialize() ==
1461 QualType::PDIK_Struct) {
1462 LValue Dst = MakeAddrLValue(emission.getAllocatedAddress(), type);
1463 if (emission.IsByRef)
1464 drillIntoBlockVariable(*this, Dst, &D);
1465 defaultInitNonTrivialCStructVar(Dst);
1466 return;
1467 }
1468
1469 if (isTrivialInitializer(Init))
1470 return;
1471
1472 // Check whether this is a byref variable that's potentially
1473 // captured and moved by its own initializer. If so, we'll need to
1474 // emit the initializer first, then copy into the variable.
1475 bool capturedByInit = emission.IsByRef && isCapturedBy(D, Init);
1476
1477 Address Loc =
1478 capturedByInit ? emission.Addr : emission.getObjectAddress(*this);
1479
1480 llvm::Constant *constant = nullptr;
1481 if (emission.IsConstantAggregate || D.isConstexpr()) {
1482 assert(!capturedByInit && "constant init contains a capturing block?");
1483 constant = ConstantEmitter(*this).tryEmitAbstractForInitializer(D);
1484 }
1485
1486 if (!constant) {
1487 LValue lv = MakeAddrLValue(Loc, type);
1488 lv.setNonGC(true);
1489 return EmitExprAsInit(Init, &D, lv, capturedByInit);
1490 }
1491
1492 if (!emission.IsConstantAggregate) {
1493 // For simple scalar/complex initialization, store the value directly.
1494 LValue lv = MakeAddrLValue(Loc, type);
1495 lv.setNonGC(true);
1496 return EmitStoreThroughLValue(RValue::get(constant), lv, true);
1497 }
1498
1499 // If this is a simple aggregate initialization, we can optimize it
1500 // in various ways.
1501 bool isVolatile = type.isVolatileQualified();
1502
1503 llvm::Value *SizeVal =
1504 llvm::ConstantInt::get(IntPtrTy,
1505 getContext().getTypeSizeInChars(type).getQuantity());
1506
1507 llvm::Type *BP = CGM.Int8Ty->getPointerTo(Loc.getAddressSpace());
1508 if (Loc.getType() != BP)
1509 Loc = Builder.CreateBitCast(Loc, BP);
1510
1511 // If the initializer is all or mostly the same, codegen with bzero / memset
1512 // then do a few stores afterward.
1513 uint64_t ConstantSize =
1514 CGM.getDataLayout().getTypeAllocSize(constant->getType());
1515 if (shouldUseBZeroPlusStoresToInitialize(constant, ConstantSize)) {
1516 Builder.CreateMemSet(Loc, llvm::ConstantInt::get(Int8Ty, 0), SizeVal,
1517 isVolatile);
1518 // Zero and undef don't require a stores.
1519 if (!constant->isNullValue() && !isa<llvm::UndefValue>(constant)) {
1520 Loc = Builder.CreateBitCast(Loc,
1521 constant->getType()->getPointerTo(Loc.getAddressSpace()));
1522 emitStoresForInitAfterBZero(CGM, constant, Loc, isVolatile, Builder);
1523 }
1524 return;
1525 }
1526
1527 BytePattern Pattern = shouldUseMemSetToInitialize(constant, ConstantSize);
1528 if (!Pattern.isNone()) {
1529 uint8_t Value = Pattern.isAny() ? 0x00 : Pattern.getValue();
1530 Builder.CreateMemSet(Loc, llvm::ConstantInt::get(Int8Ty, Value), SizeVal,
1531 isVolatile);
1532 return;
1533 }
1534
1535 // Otherwise, create a temporary global with the initializer then
1536 // memcpy from the global to the alloca.
1537 std::string Name = getStaticDeclName(CGM, D);
1538 unsigned AS = CGM.getContext().getTargetAddressSpace(
1539 CGM.getStringLiteralAddressSpace());
1540 BP = llvm::PointerType::getInt8PtrTy(getLLVMContext(), AS);
1541
1542 llvm::GlobalVariable *GV = new llvm::GlobalVariable(
1543 CGM.getModule(), constant->getType(), true,
1544 llvm::GlobalValue::PrivateLinkage, constant, Name, nullptr,
1545 llvm::GlobalValue::NotThreadLocal, AS);
1546 GV->setAlignment(Loc.getAlignment().getQuantity());
1547 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1548
1549 Address SrcPtr = Address(GV, Loc.getAlignment());
1550 if (SrcPtr.getType() != BP)
1551 SrcPtr = Builder.CreateBitCast(SrcPtr, BP);
1552
1553 Builder.CreateMemCpy(Loc, SrcPtr, SizeVal, isVolatile);
1554 }
1555
1556 /// Emit an expression as an initializer for an object (variable, field, etc.)
1557 /// at the given location. The expression is not necessarily the normal
1558 /// initializer for the object, and the address is not necessarily
1559 /// its normal location.
1560 ///
1561 /// \param init the initializing expression
1562 /// \param D the object to act as if we're initializing
1563 /// \param loc the address to initialize; its type is a pointer
1564 /// to the LLVM mapping of the object's type
1565 /// \param alignment the alignment of the address
1566 /// \param capturedByInit true if \p D is a __block variable
1567 /// whose address is potentially changed by the initializer
EmitExprAsInit(const Expr * init,const ValueDecl * D,LValue lvalue,bool capturedByInit)1568 void CodeGenFunction::EmitExprAsInit(const Expr *init, const ValueDecl *D,
1569 LValue lvalue, bool capturedByInit) {
1570 QualType type = D->getType();
1571
1572 if (type->isReferenceType()) {
1573 RValue rvalue = EmitReferenceBindingToExpr(init);
1574 if (capturedByInit)
1575 drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
1576 EmitStoreThroughLValue(rvalue, lvalue, true);
1577 return;
1578 }
1579 switch (getEvaluationKind(type)) {
1580 case TEK_Scalar:
1581 EmitScalarInit(init, D, lvalue, capturedByInit);
1582 return;
1583 case TEK_Complex: {
1584 ComplexPairTy complex = EmitComplexExpr(init);
1585 if (capturedByInit)
1586 drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
1587 EmitStoreOfComplex(complex, lvalue, /*init*/ true);
1588 return;
1589 }
1590 case TEK_Aggregate:
1591 if (type->isAtomicType()) {
1592 EmitAtomicInit(const_cast<Expr*>(init), lvalue);
1593 } else {
1594 AggValueSlot::Overlap_t Overlap = AggValueSlot::MayOverlap;
1595 if (isa<VarDecl>(D))
1596 Overlap = AggValueSlot::DoesNotOverlap;
1597 else if (auto *FD = dyn_cast<FieldDecl>(D))
1598 Overlap = overlapForFieldInit(FD);
1599 // TODO: how can we delay here if D is captured by its initializer?
1600 EmitAggExpr(init, AggValueSlot::forLValue(lvalue,
1601 AggValueSlot::IsDestructed,
1602 AggValueSlot::DoesNotNeedGCBarriers,
1603 AggValueSlot::IsNotAliased,
1604 Overlap));
1605 }
1606 return;
1607 }
1608 llvm_unreachable("bad evaluation kind");
1609 }
1610
1611 /// Enter a destroy cleanup for the given local variable.
emitAutoVarTypeCleanup(const CodeGenFunction::AutoVarEmission & emission,QualType::DestructionKind dtorKind)1612 void CodeGenFunction::emitAutoVarTypeCleanup(
1613 const CodeGenFunction::AutoVarEmission &emission,
1614 QualType::DestructionKind dtorKind) {
1615 assert(dtorKind != QualType::DK_none);
1616
1617 // Note that for __block variables, we want to destroy the
1618 // original stack object, not the possibly forwarded object.
1619 Address addr = emission.getObjectAddress(*this);
1620
1621 const VarDecl *var = emission.Variable;
1622 QualType type = var->getType();
1623
1624 CleanupKind cleanupKind = NormalAndEHCleanup;
1625 CodeGenFunction::Destroyer *destroyer = nullptr;
1626
1627 switch (dtorKind) {
1628 case QualType::DK_none:
1629 llvm_unreachable("no cleanup for trivially-destructible variable");
1630
1631 case QualType::DK_cxx_destructor:
1632 // If there's an NRVO flag on the emission, we need a different
1633 // cleanup.
1634 if (emission.NRVOFlag) {
1635 assert(!type->isArrayType());
1636 CXXDestructorDecl *dtor = type->getAsCXXRecordDecl()->getDestructor();
1637 EHStack.pushCleanup<DestroyNRVOVariableCXX>(cleanupKind, addr, dtor,
1638 emission.NRVOFlag);
1639 return;
1640 }
1641 break;
1642
1643 case QualType::DK_objc_strong_lifetime:
1644 // Suppress cleanups for pseudo-strong variables.
1645 if (var->isARCPseudoStrong()) return;
1646
1647 // Otherwise, consider whether to use an EH cleanup or not.
1648 cleanupKind = getARCCleanupKind();
1649
1650 // Use the imprecise destroyer by default.
1651 if (!var->hasAttr<ObjCPreciseLifetimeAttr>())
1652 destroyer = CodeGenFunction::destroyARCStrongImprecise;
1653 break;
1654
1655 case QualType::DK_objc_weak_lifetime:
1656 break;
1657
1658 case QualType::DK_nontrivial_c_struct:
1659 destroyer = CodeGenFunction::destroyNonTrivialCStruct;
1660 if (emission.NRVOFlag) {
1661 assert(!type->isArrayType());
1662 EHStack.pushCleanup<DestroyNRVOVariableC>(cleanupKind, addr,
1663 emission.NRVOFlag, type);
1664 return;
1665 }
1666 break;
1667 }
1668
1669 // If we haven't chosen a more specific destroyer, use the default.
1670 if (!destroyer) destroyer = getDestroyer(dtorKind);
1671
1672 // Use an EH cleanup in array destructors iff the destructor itself
1673 // is being pushed as an EH cleanup.
1674 bool useEHCleanup = (cleanupKind & EHCleanup);
1675 EHStack.pushCleanup<DestroyObject>(cleanupKind, addr, type, destroyer,
1676 useEHCleanup);
1677 }
1678
EmitAutoVarCleanups(const AutoVarEmission & emission)1679 void CodeGenFunction::EmitAutoVarCleanups(const AutoVarEmission &emission) {
1680 assert(emission.Variable && "emission was not valid!");
1681
1682 // If this was emitted as a global constant, we're done.
1683 if (emission.wasEmittedAsGlobal()) return;
1684
1685 // If we don't have an insertion point, we're done. Sema prevents
1686 // us from jumping into any of these scopes anyway.
1687 if (!HaveInsertPoint()) return;
1688
1689 const VarDecl &D = *emission.Variable;
1690
1691 // Check the type for a cleanup.
1692 if (QualType::DestructionKind dtorKind = D.getType().isDestructedType())
1693 emitAutoVarTypeCleanup(emission, dtorKind);
1694
1695 // In GC mode, honor objc_precise_lifetime.
1696 if (getLangOpts().getGC() != LangOptions::NonGC &&
1697 D.hasAttr<ObjCPreciseLifetimeAttr>()) {
1698 EHStack.pushCleanup<ExtendGCLifetime>(NormalCleanup, &D);
1699 }
1700
1701 // Handle the cleanup attribute.
1702 if (const CleanupAttr *CA = D.getAttr<CleanupAttr>()) {
1703 const FunctionDecl *FD = CA->getFunctionDecl();
1704
1705 llvm::Constant *F = CGM.GetAddrOfFunction(FD);
1706 assert(F && "Could not find function!");
1707
1708 const CGFunctionInfo &Info = CGM.getTypes().arrangeFunctionDeclaration(FD);
1709 EHStack.pushCleanup<CallCleanupFunction>(NormalAndEHCleanup, F, &Info, &D);
1710 }
1711
1712 // If this is a block variable, call _Block_object_destroy
1713 // (on the unforwarded address). Don't enter this cleanup if we're in pure-GC
1714 // mode.
1715 if (emission.IsByRef && CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
1716 BlockFieldFlags Flags = BLOCK_FIELD_IS_BYREF;
1717 if (emission.Variable->getType().isObjCGCWeak())
1718 Flags |= BLOCK_FIELD_IS_WEAK;
1719 enterByrefCleanup(NormalAndEHCleanup, emission.Addr, Flags,
1720 /*LoadBlockVarAddr*/ false);
1721 }
1722 }
1723
1724 CodeGenFunction::Destroyer *
getDestroyer(QualType::DestructionKind kind)1725 CodeGenFunction::getDestroyer(QualType::DestructionKind kind) {
1726 switch (kind) {
1727 case QualType::DK_none: llvm_unreachable("no destroyer for trivial dtor");
1728 case QualType::DK_cxx_destructor:
1729 return destroyCXXObject;
1730 case QualType::DK_objc_strong_lifetime:
1731 return destroyARCStrongPrecise;
1732 case QualType::DK_objc_weak_lifetime:
1733 return destroyARCWeak;
1734 case QualType::DK_nontrivial_c_struct:
1735 return destroyNonTrivialCStruct;
1736 }
1737 llvm_unreachable("Unknown DestructionKind");
1738 }
1739
1740 /// pushEHDestroy - Push the standard destructor for the given type as
1741 /// an EH-only cleanup.
pushEHDestroy(QualType::DestructionKind dtorKind,Address addr,QualType type)1742 void CodeGenFunction::pushEHDestroy(QualType::DestructionKind dtorKind,
1743 Address addr, QualType type) {
1744 assert(dtorKind && "cannot push destructor for trivial type");
1745 assert(needsEHCleanup(dtorKind));
1746
1747 pushDestroy(EHCleanup, addr, type, getDestroyer(dtorKind), true);
1748 }
1749
1750 /// pushDestroy - Push the standard destructor for the given type as
1751 /// at least a normal cleanup.
pushDestroy(QualType::DestructionKind dtorKind,Address addr,QualType type)1752 void CodeGenFunction::pushDestroy(QualType::DestructionKind dtorKind,
1753 Address addr, QualType type) {
1754 assert(dtorKind && "cannot push destructor for trivial type");
1755
1756 CleanupKind cleanupKind = getCleanupKind(dtorKind);
1757 pushDestroy(cleanupKind, addr, type, getDestroyer(dtorKind),
1758 cleanupKind & EHCleanup);
1759 }
1760
pushDestroy(CleanupKind cleanupKind,Address addr,QualType type,Destroyer * destroyer,bool useEHCleanupForArray)1761 void CodeGenFunction::pushDestroy(CleanupKind cleanupKind, Address addr,
1762 QualType type, Destroyer *destroyer,
1763 bool useEHCleanupForArray) {
1764 pushFullExprCleanup<DestroyObject>(cleanupKind, addr, type,
1765 destroyer, useEHCleanupForArray);
1766 }
1767
pushStackRestore(CleanupKind Kind,Address SPMem)1768 void CodeGenFunction::pushStackRestore(CleanupKind Kind, Address SPMem) {
1769 EHStack.pushCleanup<CallStackRestore>(Kind, SPMem);
1770 }
1771
pushLifetimeExtendedDestroy(CleanupKind cleanupKind,Address addr,QualType type,Destroyer * destroyer,bool useEHCleanupForArray)1772 void CodeGenFunction::pushLifetimeExtendedDestroy(
1773 CleanupKind cleanupKind, Address addr, QualType type,
1774 Destroyer *destroyer, bool useEHCleanupForArray) {
1775 // Push an EH-only cleanup for the object now.
1776 // FIXME: When popping normal cleanups, we need to keep this EH cleanup
1777 // around in case a temporary's destructor throws an exception.
1778 if (cleanupKind & EHCleanup)
1779 EHStack.pushCleanup<DestroyObject>(
1780 static_cast<CleanupKind>(cleanupKind & ~NormalCleanup), addr, type,
1781 destroyer, useEHCleanupForArray);
1782
1783 // Remember that we need to push a full cleanup for the object at the
1784 // end of the full-expression.
1785 pushCleanupAfterFullExpr<DestroyObject>(
1786 cleanupKind, addr, type, destroyer, useEHCleanupForArray);
1787 }
1788
1789 /// emitDestroy - Immediately perform the destruction of the given
1790 /// object.
1791 ///
1792 /// \param addr - the address of the object; a type*
1793 /// \param type - the type of the object; if an array type, all
1794 /// objects are destroyed in reverse order
1795 /// \param destroyer - the function to call to destroy individual
1796 /// elements
1797 /// \param useEHCleanupForArray - whether an EH cleanup should be
1798 /// used when destroying array elements, in case one of the
1799 /// destructions throws an exception
emitDestroy(Address addr,QualType type,Destroyer * destroyer,bool useEHCleanupForArray)1800 void CodeGenFunction::emitDestroy(Address addr, QualType type,
1801 Destroyer *destroyer,
1802 bool useEHCleanupForArray) {
1803 const ArrayType *arrayType = getContext().getAsArrayType(type);
1804 if (!arrayType)
1805 return destroyer(*this, addr, type);
1806
1807 llvm::Value *length = emitArrayLength(arrayType, type, addr);
1808
1809 CharUnits elementAlign =
1810 addr.getAlignment()
1811 .alignmentOfArrayElement(getContext().getTypeSizeInChars(type));
1812
1813 // Normally we have to check whether the array is zero-length.
1814 bool checkZeroLength = true;
1815
1816 // But if the array length is constant, we can suppress that.
1817 if (llvm::ConstantInt *constLength = dyn_cast<llvm::ConstantInt>(length)) {
1818 // ...and if it's constant zero, we can just skip the entire thing.
1819 if (constLength->isZero()) return;
1820 checkZeroLength = false;
1821 }
1822
1823 llvm::Value *begin = addr.getPointer();
1824 llvm::Value *end = Builder.CreateInBoundsGEP(begin, length);
1825 emitArrayDestroy(begin, end, type, elementAlign, destroyer,
1826 checkZeroLength, useEHCleanupForArray);
1827 }
1828
1829 /// emitArrayDestroy - Destroys all the elements of the given array,
1830 /// beginning from last to first. The array cannot be zero-length.
1831 ///
1832 /// \param begin - a type* denoting the first element of the array
1833 /// \param end - a type* denoting one past the end of the array
1834 /// \param elementType - the element type of the array
1835 /// \param destroyer - the function to call to destroy elements
1836 /// \param useEHCleanup - whether to push an EH cleanup to destroy
1837 /// the remaining elements in case the destruction of a single
1838 /// element throws
emitArrayDestroy(llvm::Value * begin,llvm::Value * end,QualType elementType,CharUnits elementAlign,Destroyer * destroyer,bool checkZeroLength,bool useEHCleanup)1839 void CodeGenFunction::emitArrayDestroy(llvm::Value *begin,
1840 llvm::Value *end,
1841 QualType elementType,
1842 CharUnits elementAlign,
1843 Destroyer *destroyer,
1844 bool checkZeroLength,
1845 bool useEHCleanup) {
1846 assert(!elementType->isArrayType());
1847
1848 // The basic structure here is a do-while loop, because we don't
1849 // need to check for the zero-element case.
1850 llvm::BasicBlock *bodyBB = createBasicBlock("arraydestroy.body");
1851 llvm::BasicBlock *doneBB = createBasicBlock("arraydestroy.done");
1852
1853 if (checkZeroLength) {
1854 llvm::Value *isEmpty = Builder.CreateICmpEQ(begin, end,
1855 "arraydestroy.isempty");
1856 Builder.CreateCondBr(isEmpty, doneBB, bodyBB);
1857 }
1858
1859 // Enter the loop body, making that address the current address.
1860 llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
1861 EmitBlock(bodyBB);
1862 llvm::PHINode *elementPast =
1863 Builder.CreatePHI(begin->getType(), 2, "arraydestroy.elementPast");
1864 elementPast->addIncoming(end, entryBB);
1865
1866 // Shift the address back by one element.
1867 llvm::Value *negativeOne = llvm::ConstantInt::get(SizeTy, -1, true);
1868 llvm::Value *element = Builder.CreateInBoundsGEP(elementPast, negativeOne,
1869 "arraydestroy.element");
1870
1871 if (useEHCleanup)
1872 pushRegularPartialArrayCleanup(begin, element, elementType, elementAlign,
1873 destroyer);
1874
1875 // Perform the actual destruction there.
1876 destroyer(*this, Address(element, elementAlign), elementType);
1877
1878 if (useEHCleanup)
1879 PopCleanupBlock();
1880
1881 // Check whether we've reached the end.
1882 llvm::Value *done = Builder.CreateICmpEQ(element, begin, "arraydestroy.done");
1883 Builder.CreateCondBr(done, doneBB, bodyBB);
1884 elementPast->addIncoming(element, Builder.GetInsertBlock());
1885
1886 // Done.
1887 EmitBlock(doneBB);
1888 }
1889
1890 /// Perform partial array destruction as if in an EH cleanup. Unlike
1891 /// emitArrayDestroy, the element type here may still be an array type.
emitPartialArrayDestroy(CodeGenFunction & CGF,llvm::Value * begin,llvm::Value * end,QualType type,CharUnits elementAlign,CodeGenFunction::Destroyer * destroyer)1892 static void emitPartialArrayDestroy(CodeGenFunction &CGF,
1893 llvm::Value *begin, llvm::Value *end,
1894 QualType type, CharUnits elementAlign,
1895 CodeGenFunction::Destroyer *destroyer) {
1896 // If the element type is itself an array, drill down.
1897 unsigned arrayDepth = 0;
1898 while (const ArrayType *arrayType = CGF.getContext().getAsArrayType(type)) {
1899 // VLAs don't require a GEP index to walk into.
1900 if (!isa<VariableArrayType>(arrayType))
1901 arrayDepth++;
1902 type = arrayType->getElementType();
1903 }
1904
1905 if (arrayDepth) {
1906 llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
1907
1908 SmallVector<llvm::Value*,4> gepIndices(arrayDepth+1, zero);
1909 begin = CGF.Builder.CreateInBoundsGEP(begin, gepIndices, "pad.arraybegin");
1910 end = CGF.Builder.CreateInBoundsGEP(end, gepIndices, "pad.arrayend");
1911 }
1912
1913 // Destroy the array. We don't ever need an EH cleanup because we
1914 // assume that we're in an EH cleanup ourselves, so a throwing
1915 // destructor causes an immediate terminate.
1916 CGF.emitArrayDestroy(begin, end, type, elementAlign, destroyer,
1917 /*checkZeroLength*/ true, /*useEHCleanup*/ false);
1918 }
1919
1920 namespace {
1921 /// RegularPartialArrayDestroy - a cleanup which performs a partial
1922 /// array destroy where the end pointer is regularly determined and
1923 /// does not need to be loaded from a local.
1924 class RegularPartialArrayDestroy final : public EHScopeStack::Cleanup {
1925 llvm::Value *ArrayBegin;
1926 llvm::Value *ArrayEnd;
1927 QualType ElementType;
1928 CodeGenFunction::Destroyer *Destroyer;
1929 CharUnits ElementAlign;
1930 public:
RegularPartialArrayDestroy(llvm::Value * arrayBegin,llvm::Value * arrayEnd,QualType elementType,CharUnits elementAlign,CodeGenFunction::Destroyer * destroyer)1931 RegularPartialArrayDestroy(llvm::Value *arrayBegin, llvm::Value *arrayEnd,
1932 QualType elementType, CharUnits elementAlign,
1933 CodeGenFunction::Destroyer *destroyer)
1934 : ArrayBegin(arrayBegin), ArrayEnd(arrayEnd),
1935 ElementType(elementType), Destroyer(destroyer),
1936 ElementAlign(elementAlign) {}
1937
Emit(CodeGenFunction & CGF,Flags flags)1938 void Emit(CodeGenFunction &CGF, Flags flags) override {
1939 emitPartialArrayDestroy(CGF, ArrayBegin, ArrayEnd,
1940 ElementType, ElementAlign, Destroyer);
1941 }
1942 };
1943
1944 /// IrregularPartialArrayDestroy - a cleanup which performs a
1945 /// partial array destroy where the end pointer is irregularly
1946 /// determined and must be loaded from a local.
1947 class IrregularPartialArrayDestroy final : public EHScopeStack::Cleanup {
1948 llvm::Value *ArrayBegin;
1949 Address ArrayEndPointer;
1950 QualType ElementType;
1951 CodeGenFunction::Destroyer *Destroyer;
1952 CharUnits ElementAlign;
1953 public:
IrregularPartialArrayDestroy(llvm::Value * arrayBegin,Address arrayEndPointer,QualType elementType,CharUnits elementAlign,CodeGenFunction::Destroyer * destroyer)1954 IrregularPartialArrayDestroy(llvm::Value *arrayBegin,
1955 Address arrayEndPointer,
1956 QualType elementType,
1957 CharUnits elementAlign,
1958 CodeGenFunction::Destroyer *destroyer)
1959 : ArrayBegin(arrayBegin), ArrayEndPointer(arrayEndPointer),
1960 ElementType(elementType), Destroyer(destroyer),
1961 ElementAlign(elementAlign) {}
1962
Emit(CodeGenFunction & CGF,Flags flags)1963 void Emit(CodeGenFunction &CGF, Flags flags) override {
1964 llvm::Value *arrayEnd = CGF.Builder.CreateLoad(ArrayEndPointer);
1965 emitPartialArrayDestroy(CGF, ArrayBegin, arrayEnd,
1966 ElementType, ElementAlign, Destroyer);
1967 }
1968 };
1969 } // end anonymous namespace
1970
1971 /// pushIrregularPartialArrayCleanup - Push an EH cleanup to destroy
1972 /// already-constructed elements of the given array. The cleanup
1973 /// may be popped with DeactivateCleanupBlock or PopCleanupBlock.
1974 ///
1975 /// \param elementType - the immediate element type of the array;
1976 /// possibly still an array type
pushIrregularPartialArrayCleanup(llvm::Value * arrayBegin,Address arrayEndPointer,QualType elementType,CharUnits elementAlign,Destroyer * destroyer)1977 void CodeGenFunction::pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin,
1978 Address arrayEndPointer,
1979 QualType elementType,
1980 CharUnits elementAlign,
1981 Destroyer *destroyer) {
1982 pushFullExprCleanup<IrregularPartialArrayDestroy>(EHCleanup,
1983 arrayBegin, arrayEndPointer,
1984 elementType, elementAlign,
1985 destroyer);
1986 }
1987
1988 /// pushRegularPartialArrayCleanup - Push an EH cleanup to destroy
1989 /// already-constructed elements of the given array. The cleanup
1990 /// may be popped with DeactivateCleanupBlock or PopCleanupBlock.
1991 ///
1992 /// \param elementType - the immediate element type of the array;
1993 /// possibly still an array type
pushRegularPartialArrayCleanup(llvm::Value * arrayBegin,llvm::Value * arrayEnd,QualType elementType,CharUnits elementAlign,Destroyer * destroyer)1994 void CodeGenFunction::pushRegularPartialArrayCleanup(llvm::Value *arrayBegin,
1995 llvm::Value *arrayEnd,
1996 QualType elementType,
1997 CharUnits elementAlign,
1998 Destroyer *destroyer) {
1999 pushFullExprCleanup<RegularPartialArrayDestroy>(EHCleanup,
2000 arrayBegin, arrayEnd,
2001 elementType, elementAlign,
2002 destroyer);
2003 }
2004
2005 /// Lazily declare the @llvm.lifetime.start intrinsic.
getLLVMLifetimeStartFn()2006 llvm::Constant *CodeGenModule::getLLVMLifetimeStartFn() {
2007 if (LifetimeStartFn)
2008 return LifetimeStartFn;
2009 LifetimeStartFn = llvm::Intrinsic::getDeclaration(&getModule(),
2010 llvm::Intrinsic::lifetime_start, AllocaInt8PtrTy);
2011 return LifetimeStartFn;
2012 }
2013
2014 /// Lazily declare the @llvm.lifetime.end intrinsic.
getLLVMLifetimeEndFn()2015 llvm::Constant *CodeGenModule::getLLVMLifetimeEndFn() {
2016 if (LifetimeEndFn)
2017 return LifetimeEndFn;
2018 LifetimeEndFn = llvm::Intrinsic::getDeclaration(&getModule(),
2019 llvm::Intrinsic::lifetime_end, AllocaInt8PtrTy);
2020 return LifetimeEndFn;
2021 }
2022
2023 namespace {
2024 /// A cleanup to perform a release of an object at the end of a
2025 /// function. This is used to balance out the incoming +1 of a
2026 /// ns_consumed argument when we can't reasonably do that just by
2027 /// not doing the initial retain for a __block argument.
2028 struct ConsumeARCParameter final : EHScopeStack::Cleanup {
ConsumeARCParameter__anonef83e6cc0311::ConsumeARCParameter2029 ConsumeARCParameter(llvm::Value *param,
2030 ARCPreciseLifetime_t precise)
2031 : Param(param), Precise(precise) {}
2032
2033 llvm::Value *Param;
2034 ARCPreciseLifetime_t Precise;
2035
Emit__anonef83e6cc0311::ConsumeARCParameter2036 void Emit(CodeGenFunction &CGF, Flags flags) override {
2037 CGF.EmitARCRelease(Param, Precise);
2038 }
2039 };
2040 } // end anonymous namespace
2041
2042 /// Emit an alloca (or GlobalValue depending on target)
2043 /// for the specified parameter and set up LocalDeclMap.
EmitParmDecl(const VarDecl & D,ParamValue Arg,unsigned ArgNo)2044 void CodeGenFunction::EmitParmDecl(const VarDecl &D, ParamValue Arg,
2045 unsigned ArgNo) {
2046 // FIXME: Why isn't ImplicitParamDecl a ParmVarDecl?
2047 assert((isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D)) &&
2048 "Invalid argument to EmitParmDecl");
2049
2050 Arg.getAnyValue()->setName(D.getName());
2051
2052 QualType Ty = D.getType();
2053
2054 // Use better IR generation for certain implicit parameters.
2055 if (auto IPD = dyn_cast<ImplicitParamDecl>(&D)) {
2056 // The only implicit argument a block has is its literal.
2057 // This may be passed as an inalloca'ed value on Windows x86.
2058 if (BlockInfo) {
2059 llvm::Value *V = Arg.isIndirect()
2060 ? Builder.CreateLoad(Arg.getIndirectAddress())
2061 : Arg.getDirectValue();
2062 setBlockContextParameter(IPD, ArgNo, V);
2063 return;
2064 }
2065 }
2066
2067 Address DeclPtr = Address::invalid();
2068 bool DoStore = false;
2069 bool IsScalar = hasScalarEvaluationKind(Ty);
2070 // If we already have a pointer to the argument, reuse the input pointer.
2071 if (Arg.isIndirect()) {
2072 DeclPtr = Arg.getIndirectAddress();
2073 // If we have a prettier pointer type at this point, bitcast to that.
2074 unsigned AS = DeclPtr.getType()->getAddressSpace();
2075 llvm::Type *IRTy = ConvertTypeForMem(Ty)->getPointerTo(AS);
2076 if (DeclPtr.getType() != IRTy)
2077 DeclPtr = Builder.CreateBitCast(DeclPtr, IRTy, D.getName());
2078 // Indirect argument is in alloca address space, which may be different
2079 // from the default address space.
2080 auto AllocaAS = CGM.getASTAllocaAddressSpace();
2081 auto *V = DeclPtr.getPointer();
2082 auto SrcLangAS = getLangOpts().OpenCL ? LangAS::opencl_private : AllocaAS;
2083 auto DestLangAS =
2084 getLangOpts().OpenCL ? LangAS::opencl_private : LangAS::Default;
2085 if (SrcLangAS != DestLangAS) {
2086 assert(getContext().getTargetAddressSpace(SrcLangAS) ==
2087 CGM.getDataLayout().getAllocaAddrSpace());
2088 auto DestAS = getContext().getTargetAddressSpace(DestLangAS);
2089 auto *T = V->getType()->getPointerElementType()->getPointerTo(DestAS);
2090 DeclPtr = Address(getTargetHooks().performAddrSpaceCast(
2091 *this, V, SrcLangAS, DestLangAS, T, true),
2092 DeclPtr.getAlignment());
2093 }
2094
2095 // Push a destructor cleanup for this parameter if the ABI requires it.
2096 // Don't push a cleanup in a thunk for a method that will also emit a
2097 // cleanup.
2098 if (hasAggregateEvaluationKind(Ty) && !CurFuncIsThunk &&
2099 Ty->getAs<RecordType>()->getDecl()->isParamDestroyedInCallee()) {
2100 if (QualType::DestructionKind DtorKind = Ty.isDestructedType()) {
2101 assert((DtorKind == QualType::DK_cxx_destructor ||
2102 DtorKind == QualType::DK_nontrivial_c_struct) &&
2103 "unexpected destructor type");
2104 pushDestroy(DtorKind, DeclPtr, Ty);
2105 CalleeDestructedParamCleanups[cast<ParmVarDecl>(&D)] =
2106 EHStack.stable_begin();
2107 }
2108 }
2109 } else {
2110 // Check if the parameter address is controlled by OpenMP runtime.
2111 Address OpenMPLocalAddr =
2112 getLangOpts().OpenMP
2113 ? CGM.getOpenMPRuntime().getAddressOfLocalVariable(*this, &D)
2114 : Address::invalid();
2115 if (getLangOpts().OpenMP && OpenMPLocalAddr.isValid()) {
2116 DeclPtr = OpenMPLocalAddr;
2117 } else {
2118 // Otherwise, create a temporary to hold the value.
2119 DeclPtr = CreateMemTemp(Ty, getContext().getDeclAlign(&D),
2120 D.getName() + ".addr");
2121 }
2122 DoStore = true;
2123 }
2124
2125 llvm::Value *ArgVal = (DoStore ? Arg.getDirectValue() : nullptr);
2126
2127 LValue lv = MakeAddrLValue(DeclPtr, Ty);
2128 if (IsScalar) {
2129 Qualifiers qs = Ty.getQualifiers();
2130 if (Qualifiers::ObjCLifetime lt = qs.getObjCLifetime()) {
2131 // We honor __attribute__((ns_consumed)) for types with lifetime.
2132 // For __strong, it's handled by just skipping the initial retain;
2133 // otherwise we have to balance out the initial +1 with an extra
2134 // cleanup to do the release at the end of the function.
2135 bool isConsumed = D.hasAttr<NSConsumedAttr>();
2136
2137 // 'self' is always formally __strong, but if this is not an
2138 // init method then we don't want to retain it.
2139 if (D.isARCPseudoStrong()) {
2140 const ObjCMethodDecl *method = cast<ObjCMethodDecl>(CurCodeDecl);
2141 assert(&D == method->getSelfDecl());
2142 assert(lt == Qualifiers::OCL_Strong);
2143 assert(qs.hasConst());
2144 assert(method->getMethodFamily() != OMF_init);
2145 (void) method;
2146 lt = Qualifiers::OCL_ExplicitNone;
2147 }
2148
2149 // Load objects passed indirectly.
2150 if (Arg.isIndirect() && !ArgVal)
2151 ArgVal = Builder.CreateLoad(DeclPtr);
2152
2153 if (lt == Qualifiers::OCL_Strong) {
2154 if (!isConsumed) {
2155 if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
2156 // use objc_storeStrong(&dest, value) for retaining the
2157 // object. But first, store a null into 'dest' because
2158 // objc_storeStrong attempts to release its old value.
2159 llvm::Value *Null = CGM.EmitNullConstant(D.getType());
2160 EmitStoreOfScalar(Null, lv, /* isInitialization */ true);
2161 EmitARCStoreStrongCall(lv.getAddress(), ArgVal, true);
2162 DoStore = false;
2163 }
2164 else
2165 // Don't use objc_retainBlock for block pointers, because we
2166 // don't want to Block_copy something just because we got it
2167 // as a parameter.
2168 ArgVal = EmitARCRetainNonBlock(ArgVal);
2169 }
2170 } else {
2171 // Push the cleanup for a consumed parameter.
2172 if (isConsumed) {
2173 ARCPreciseLifetime_t precise = (D.hasAttr<ObjCPreciseLifetimeAttr>()
2174 ? ARCPreciseLifetime : ARCImpreciseLifetime);
2175 EHStack.pushCleanup<ConsumeARCParameter>(getARCCleanupKind(), ArgVal,
2176 precise);
2177 }
2178
2179 if (lt == Qualifiers::OCL_Weak) {
2180 EmitARCInitWeak(DeclPtr, ArgVal);
2181 DoStore = false; // The weak init is a store, no need to do two.
2182 }
2183 }
2184
2185 // Enter the cleanup scope.
2186 EmitAutoVarWithLifetime(*this, D, DeclPtr, lt);
2187 }
2188 }
2189
2190 // Store the initial value into the alloca.
2191 if (DoStore)
2192 EmitStoreOfScalar(ArgVal, lv, /* isInitialization */ true);
2193
2194 setAddrOfLocalVar(&D, DeclPtr);
2195
2196 // Emit debug info for param declaration.
2197 if (CGDebugInfo *DI = getDebugInfo()) {
2198 if (CGM.getCodeGenOpts().getDebugInfo() >=
2199 codegenoptions::LimitedDebugInfo) {
2200 DI->EmitDeclareOfArgVariable(&D, DeclPtr.getPointer(), ArgNo, Builder);
2201 }
2202 }
2203
2204 if (D.hasAttr<AnnotateAttr>())
2205 EmitVarAnnotations(&D, DeclPtr.getPointer());
2206
2207 // We can only check return value nullability if all arguments to the
2208 // function satisfy their nullability preconditions. This makes it necessary
2209 // to emit null checks for args in the function body itself.
2210 if (requiresReturnValueNullabilityCheck()) {
2211 auto Nullability = Ty->getNullability(getContext());
2212 if (Nullability && *Nullability == NullabilityKind::NonNull) {
2213 SanitizerScope SanScope(this);
2214 RetValNullabilityPrecondition =
2215 Builder.CreateAnd(RetValNullabilityPrecondition,
2216 Builder.CreateIsNotNull(Arg.getAnyValue()));
2217 }
2218 }
2219 }
2220
EmitOMPDeclareReduction(const OMPDeclareReductionDecl * D,CodeGenFunction * CGF)2221 void CodeGenModule::EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D,
2222 CodeGenFunction *CGF) {
2223 if (!LangOpts.OpenMP || (!LangOpts.EmitAllDecls && !D->isUsed()))
2224 return;
2225 getOpenMPRuntime().emitUserDefinedReduction(CGF, D);
2226 }
2227