clang  8.0.0
CGDecl.cpp
Go to the documentation of this file.
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"
31 #include "clang/Basic/TargetInfo.h"
33 #include "llvm/Analysis/ValueTracking.h"
34 #include "llvm/IR/DataLayout.h"
35 #include "llvm/IR/GlobalVariable.h"
36 #include "llvm/IR/Intrinsics.h"
37 #include "llvm/IR/Type.h"
38 
39 using namespace clang;
40 using namespace CodeGen;
41 
43  switch (D.getKind()) {
44  case Decl::BuiltinTemplate:
45  case Decl::TranslationUnit:
46  case Decl::ExternCContext:
47  case Decl::Namespace:
48  case Decl::UnresolvedUsingTypename:
49  case Decl::ClassTemplateSpecialization:
50  case Decl::ClassTemplatePartialSpecialization:
51  case Decl::VarTemplateSpecialization:
52  case Decl::VarTemplatePartialSpecialization:
53  case Decl::TemplateTypeParm:
54  case Decl::UnresolvedUsingValue:
55  case Decl::NonTypeTemplateParm:
56  case Decl::CXXDeductionGuide:
57  case Decl::CXXMethod:
58  case Decl::CXXConstructor:
59  case Decl::CXXDestructor:
60  case Decl::CXXConversion:
61  case Decl::Field:
62  case Decl::MSProperty:
63  case Decl::IndirectField:
64  case Decl::ObjCIvar:
65  case Decl::ObjCAtDefsField:
66  case Decl::ParmVar:
67  case Decl::ImplicitParam:
68  case Decl::ClassTemplate:
69  case Decl::VarTemplate:
70  case Decl::FunctionTemplate:
71  case Decl::TypeAliasTemplate:
72  case Decl::TemplateTemplateParm:
73  case Decl::ObjCMethod:
74  case Decl::ObjCCategory:
75  case Decl::ObjCProtocol:
76  case Decl::ObjCInterface:
77  case Decl::ObjCCategoryImpl:
78  case Decl::ObjCImplementation:
79  case Decl::ObjCProperty:
80  case Decl::ObjCCompatibleAlias:
81  case Decl::PragmaComment:
82  case Decl::PragmaDetectMismatch:
83  case Decl::AccessSpec:
84  case Decl::LinkageSpec:
85  case Decl::Export:
86  case Decl::ObjCPropertyImpl:
87  case Decl::FileScopeAsm:
88  case Decl::Friend:
89  case Decl::FriendTemplate:
90  case Decl::Block:
91  case Decl::Captured:
92  case Decl::ClassScopeFunctionSpecialization:
93  case Decl::UsingShadow:
94  case Decl::ConstructorUsingShadow:
95  case Decl::ObjCTypeParam:
96  case Decl::Binding:
97  llvm_unreachable("Declaration should not be in declstmts!");
98  case Decl::Function: // void X();
99  case Decl::Record: // struct/union/class X;
100  case Decl::Enum: // enum X;
101  case Decl::EnumConstant: // enum ? { X = ? }
102  case Decl::CXXRecord: // struct/union/class X; [C++]
103  case Decl::StaticAssert: // static_assert(X, ""); [C++0x]
104  case Decl::Label: // __label__ x;
105  case Decl::Import:
106  case Decl::OMPThreadPrivate:
107  case Decl::OMPCapturedExpr:
108  case Decl::OMPRequires:
109  case Decl::Empty:
110  // None of these decls require codegen support.
111  return;
112 
113  case Decl::NamespaceAlias:
114  if (CGDebugInfo *DI = getDebugInfo())
115  DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(D));
116  return;
117  case Decl::Using: // using X; [C++]
118  if (CGDebugInfo *DI = getDebugInfo())
119  DI->EmitUsingDecl(cast<UsingDecl>(D));
120  return;
121  case Decl::UsingPack:
122  for (auto *Using : cast<UsingPackDecl>(D).expansions())
123  EmitDecl(*Using);
124  return;
125  case Decl::UsingDirective: // using namespace X; [C++]
126  if (CGDebugInfo *DI = getDebugInfo())
127  DI->EmitUsingDirective(cast<UsingDirectiveDecl>(D));
128  return;
129  case Decl::Var:
130  case Decl::Decomposition: {
131  const VarDecl &VD = cast<VarDecl>(D);
132  assert(VD.isLocalVarDecl() &&
133  "Should not see file-scope variables inside a function!");
134  EmitVarDecl(VD);
135  if (auto *DD = dyn_cast<DecompositionDecl>(&VD))
136  for (auto *B : DD->bindings())
137  if (auto *HD = B->getHoldingVar())
138  EmitVarDecl(*HD);
139  return;
140  }
141 
142  case Decl::OMPDeclareReduction:
143  return CGM.EmitOMPDeclareReduction(cast<OMPDeclareReductionDecl>(&D), this);
144 
145  case Decl::Typedef: // typedef int X;
146  case Decl::TypeAlias: { // using X = int; [C++0x]
147  const TypedefNameDecl &TD = cast<TypedefNameDecl>(D);
148  QualType Ty = TD.getUnderlyingType();
149 
150  if (Ty->isVariablyModifiedType())
152  }
153  }
154 }
155 
156 /// EmitVarDecl - This method handles emission of any variable declaration
157 /// inside a function, including static vars etc.
159  if (D.hasExternalStorage())
160  // Don't emit it now, allow it to be emitted lazily on its first use.
161  return;
162 
163  // Some function-scope variable does not have static storage but still
164  // needs to be emitted like a static variable, e.g. a function-scope
165  // variable in constant address space in OpenCL.
166  if (D.getStorageDuration() != SD_Automatic) {
167  // Static sampler variables translated to function calls.
168  if (D.getType()->isSamplerT())
169  return;
170 
171  llvm::GlobalValue::LinkageTypes Linkage =
172  CGM.getLLVMLinkageVarDefinition(&D, /*isConstant=*/false);
173 
174  // FIXME: We need to force the emission/use of a guard variable for
175  // some variables even if we can constant-evaluate them because
176  // we can't guarantee every translation unit will constant-evaluate them.
177 
178  return EmitStaticVarDecl(D, Linkage);
179  }
180 
183 
184  assert(D.hasLocalStorage());
185  return EmitAutoVarDecl(D);
186 }
187 
188 static std::string getStaticDeclName(CodeGenModule &CGM, const VarDecl &D) {
189  if (CGM.getLangOpts().CPlusPlus)
190  return CGM.getMangledName(&D).str();
191 
192  // If this isn't C++, we don't need a mangled name, just a pretty one.
193  assert(!D.isExternallyVisible() && "name shouldn't matter");
194  std::string ContextName;
195  const DeclContext *DC = D.getDeclContext();
196  if (auto *CD = dyn_cast<CapturedDecl>(DC))
197  DC = cast<DeclContext>(CD->getNonClosureContext());
198  if (const auto *FD = dyn_cast<FunctionDecl>(DC))
199  ContextName = CGM.getMangledName(FD);
200  else if (const auto *BD = dyn_cast<BlockDecl>(DC))
201  ContextName = CGM.getBlockMangledName(GlobalDecl(), BD);
202  else if (const auto *OMD = dyn_cast<ObjCMethodDecl>(DC))
203  ContextName = OMD->getSelector().getAsString();
204  else
205  llvm_unreachable("Unknown context for static var decl");
206 
207  ContextName += "." + D.getNameAsString();
208  return ContextName;
209 }
210 
212  const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage) {
213  // In general, we don't always emit static var decls once before we reference
214  // them. It is possible to reference them before emitting the function that
215  // contains them, and it is possible to emit the containing function multiple
216  // times.
217  if (llvm::Constant *ExistingGV = StaticLocalDeclMap[&D])
218  return ExistingGV;
219 
220  QualType Ty = D.getType();
221  assert(Ty->isConstantSizeType() && "VLAs can't be static");
222 
223  // Use the label if the variable is renamed with the asm-label extension.
224  std::string Name;
225  if (D.hasAttr<AsmLabelAttr>())
226  Name = getMangledName(&D);
227  else
228  Name = getStaticDeclName(*this, D);
229 
231  LangAS AS = GetGlobalVarAddressSpace(&D);
232  unsigned TargetAS = getContext().getTargetAddressSpace(AS);
233 
234  // OpenCL variables in local address space and CUDA shared
235  // variables cannot have an initializer.
236  llvm::Constant *Init = nullptr;
238  D.hasAttr<CUDASharedAttr>())
239  Init = llvm::UndefValue::get(LTy);
240  else
241  Init = EmitNullConstant(Ty);
242 
243  llvm::GlobalVariable *GV = new llvm::GlobalVariable(
244  getModule(), LTy, Ty.isConstant(getContext()), Linkage, Init, Name,
245  nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
246  GV->setAlignment(getContext().getDeclAlign(&D).getQuantity());
247 
248  if (supportsCOMDAT() && GV->isWeakForLinker())
249  GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
250 
251  if (D.getTLSKind())
252  setTLSMode(GV, D);
253 
254  setGVProperties(GV, &D);
255 
256  // Make sure the result is of the correct type.
257  LangAS ExpectedAS = Ty.getAddressSpace();
258  llvm::Constant *Addr = GV;
259  if (AS != ExpectedAS) {
260  Addr = getTargetCodeGenInfo().performAddrSpaceCast(
261  *this, GV, AS, ExpectedAS,
262  LTy->getPointerTo(getContext().getTargetAddressSpace(ExpectedAS)));
263  }
264 
265  setStaticLocalDeclAddress(&D, Addr);
266 
267  // Ensure that the static local gets initialized by making sure the parent
268  // function gets emitted eventually.
269  const Decl *DC = cast<Decl>(D.getDeclContext());
270 
271  // We can't name blocks or captured statements directly, so try to emit their
272  // parents.
273  if (isa<BlockDecl>(DC) || isa<CapturedDecl>(DC)) {
274  DC = DC->getNonClosureContext();
275  // FIXME: Ensure that global blocks get emitted.
276  if (!DC)
277  return Addr;
278  }
279 
280  GlobalDecl GD;
281  if (const auto *CD = dyn_cast<CXXConstructorDecl>(DC))
282  GD = GlobalDecl(CD, Ctor_Base);
283  else if (const auto *DD = dyn_cast<CXXDestructorDecl>(DC))
284  GD = GlobalDecl(DD, Dtor_Base);
285  else if (const auto *FD = dyn_cast<FunctionDecl>(DC))
286  GD = GlobalDecl(FD);
287  else {
288  // Don't do anything for Obj-C method decls or global closures. We should
289  // never defer them.
290  assert(isa<ObjCMethodDecl>(DC) && "unexpected parent code decl");
291  }
292  if (GD.getDecl()) {
293  // Disable emission of the parent function for the OpenMP device codegen.
295  (void)GetAddrOfGlobal(GD);
296  }
297 
298  return Addr;
299 }
300 
301 /// hasNontrivialDestruction - Determine whether a type's destruction is
302 /// non-trivial. If so, and the variable uses static initialization, we must
303 /// register its destructor to run on exit.
306  return RD && !RD->hasTrivialDestructor();
307 }
308 
309 /// AddInitializerToStaticVarDecl - Add the initializer for 'D' to the
310 /// global variable that has already been created for it. If the initializer
311 /// has a different type than GV does, this may free GV and return a different
312 /// one. Otherwise it just returns GV.
313 llvm::GlobalVariable *
315  llvm::GlobalVariable *GV) {
316  ConstantEmitter emitter(*this);
317  llvm::Constant *Init = emitter.tryEmitForInitializer(D);
318 
319  // If constant emission failed, then this should be a C++ static
320  // initializer.
321  if (!Init) {
322  if (!getLangOpts().CPlusPlus)
323  CGM.ErrorUnsupported(D.getInit(), "constant l-value expression");
324  else if (HaveInsertPoint()) {
325  // Since we have a static initializer, this global variable can't
326  // be constant.
327  GV->setConstant(false);
328 
329  EmitCXXGuardedInit(D, GV, /*PerformInit*/true);
330  }
331  return GV;
332  }
333 
334  // The initializer may differ in type from the global. Rewrite
335  // the global to match the initializer. (We have to do this
336  // because some types, like unions, can't be completely represented
337  // in the LLVM type system.)
338  if (GV->getType()->getElementType() != Init->getType()) {
339  llvm::GlobalVariable *OldGV = GV;
340 
341  GV = new llvm::GlobalVariable(CGM.getModule(), Init->getType(),
342  OldGV->isConstant(),
343  OldGV->getLinkage(), Init, "",
344  /*InsertBefore*/ OldGV,
345  OldGV->getThreadLocalMode(),
347  GV->setVisibility(OldGV->getVisibility());
348  GV->setDSOLocal(OldGV->isDSOLocal());
349  GV->setComdat(OldGV->getComdat());
350 
351  // Steal the name of the old global
352  GV->takeName(OldGV);
353 
354  // Replace all uses of the old global with the new global
355  llvm::Constant *NewPtrForOldDecl =
356  llvm::ConstantExpr::getBitCast(GV, OldGV->getType());
357  OldGV->replaceAllUsesWith(NewPtrForOldDecl);
358 
359  // Erase the old global, since it is no longer used.
360  OldGV->eraseFromParent();
361  }
362 
363  GV->setConstant(CGM.isTypeConstant(D.getType(), true));
364  GV->setInitializer(Init);
365 
366  emitter.finalize(GV);
367 
369  // We have a constant initializer, but a nontrivial destructor. We still
370  // need to perform a guarded "initialization" in order to register the
371  // destructor.
372  EmitCXXGuardedInit(D, GV, /*PerformInit*/false);
373  }
374 
375  return GV;
376 }
377 
379  llvm::GlobalValue::LinkageTypes Linkage) {
380  // Check to see if we already have a global variable for this
381  // declaration. This can happen when double-emitting function
382  // bodies, e.g. with complete and base constructors.
383  llvm::Constant *addr = CGM.getOrCreateStaticVarDecl(D, Linkage);
384  CharUnits alignment = getContext().getDeclAlign(&D);
385 
386  // Store into LocalDeclMap before generating initializer to handle
387  // circular references.
388  setAddrOfLocalVar(&D, Address(addr, alignment));
389 
390  // We can't have a VLA here, but we can have a pointer to a VLA,
391  // even though that doesn't really make any sense.
392  // Make sure to evaluate VLA bounds now so that we have them for later.
393  if (D.getType()->isVariablyModifiedType())
395 
396  // Save the type in case adding the initializer forces a type change.
397  llvm::Type *expectedType = addr->getType();
398 
399  llvm::GlobalVariable *var =
400  cast<llvm::GlobalVariable>(addr->stripPointerCasts());
401 
402  // CUDA's local and local static __shared__ variables should not
403  // have any non-empty initializers. This is ensured by Sema.
404  // Whatever initializer such variable may have when it gets here is
405  // a no-op and should not be emitted.
406  bool isCudaSharedVar = getLangOpts().CUDA && getLangOpts().CUDAIsDevice &&
407  D.hasAttr<CUDASharedAttr>();
408  // If this value has an initializer, emit it.
409  if (D.getInit() && !isCudaSharedVar)
410  var = AddInitializerToStaticVarDecl(D, var);
411 
412  var->setAlignment(alignment.getQuantity());
413 
414  if (D.hasAttr<AnnotateAttr>())
415  CGM.AddGlobalAnnotations(&D, var);
416 
417  if (auto *SA = D.getAttr<PragmaClangBSSSectionAttr>())
418  var->addAttribute("bss-section", SA->getName());
419  if (auto *SA = D.getAttr<PragmaClangDataSectionAttr>())
420  var->addAttribute("data-section", SA->getName());
421  if (auto *SA = D.getAttr<PragmaClangRodataSectionAttr>())
422  var->addAttribute("rodata-section", SA->getName());
423 
424  if (const SectionAttr *SA = D.getAttr<SectionAttr>())
425  var->setSection(SA->getName());
426 
427  if (D.hasAttr<UsedAttr>())
428  CGM.addUsedGlobal(var);
429 
430  // We may have to cast the constant because of the initializer
431  // mismatch above.
432  //
433  // FIXME: It is really dangerous to store this in the map; if anyone
434  // RAUW's the GV uses of this constant will be invalid.
435  llvm::Constant *castedAddr =
436  llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(var, expectedType);
437  if (var != castedAddr)
438  LocalDeclMap.find(&D)->second = Address(castedAddr, alignment);
439  CGM.setStaticLocalDeclAddress(&D, castedAddr);
440 
442 
443  // Emit global variable debug descriptor for static vars.
444  CGDebugInfo *DI = getDebugInfo();
445  if (DI &&
447  DI->setLocation(D.getLocation());
448  DI->EmitGlobalVariable(var, &D);
449  }
450 }
451 
452 namespace {
453  struct DestroyObject final : EHScopeStack::Cleanup {
454  DestroyObject(Address addr, QualType type,
455  CodeGenFunction::Destroyer *destroyer,
456  bool useEHCleanupForArray)
457  : addr(addr), type(type), destroyer(destroyer),
458  useEHCleanupForArray(useEHCleanupForArray) {}
459 
460  Address addr;
461  QualType type;
462  CodeGenFunction::Destroyer *destroyer;
463  bool useEHCleanupForArray;
464 
465  void Emit(CodeGenFunction &CGF, Flags flags) override {
466  // Don't use an EH cleanup recursively from an EH cleanup.
467  bool useEHCleanupForArray =
468  flags.isForNormalCleanup() && this->useEHCleanupForArray;
469 
470  CGF.emitDestroy(addr, type, destroyer, useEHCleanupForArray);
471  }
472  };
473 
474  template <class Derived>
475  struct DestroyNRVOVariable : EHScopeStack::Cleanup {
476  DestroyNRVOVariable(Address addr, llvm::Value *NRVOFlag)
477  : NRVOFlag(NRVOFlag), Loc(addr) {}
478 
479  llvm::Value *NRVOFlag;
480  Address Loc;
481 
482  void Emit(CodeGenFunction &CGF, Flags flags) override {
483  // Along the exceptions path we always execute the dtor.
484  bool NRVO = flags.isForNormalCleanup() && NRVOFlag;
485 
486  llvm::BasicBlock *SkipDtorBB = nullptr;
487  if (NRVO) {
488  // If we exited via NRVO, we skip the destructor call.
489  llvm::BasicBlock *RunDtorBB = CGF.createBasicBlock("nrvo.unused");
490  SkipDtorBB = CGF.createBasicBlock("nrvo.skipdtor");
491  llvm::Value *DidNRVO =
492  CGF.Builder.CreateFlagLoad(NRVOFlag, "nrvo.val");
493  CGF.Builder.CreateCondBr(DidNRVO, SkipDtorBB, RunDtorBB);
494  CGF.EmitBlock(RunDtorBB);
495  }
496 
497  static_cast<Derived *>(this)->emitDestructorCall(CGF);
498 
499  if (NRVO) CGF.EmitBlock(SkipDtorBB);
500  }
501 
502  virtual ~DestroyNRVOVariable() = default;
503  };
504 
505  struct DestroyNRVOVariableCXX final
506  : DestroyNRVOVariable<DestroyNRVOVariableCXX> {
507  DestroyNRVOVariableCXX(Address addr, const CXXDestructorDecl *Dtor,
508  llvm::Value *NRVOFlag)
509  : DestroyNRVOVariable<DestroyNRVOVariableCXX>(addr, NRVOFlag),
510  Dtor(Dtor) {}
511 
512  const CXXDestructorDecl *Dtor;
513 
514  void emitDestructorCall(CodeGenFunction &CGF) {
516  /*ForVirtualBase=*/false,
517  /*Delegating=*/false, Loc);
518  }
519  };
520 
521  struct DestroyNRVOVariableC final
522  : DestroyNRVOVariable<DestroyNRVOVariableC> {
523  DestroyNRVOVariableC(Address addr, llvm::Value *NRVOFlag, QualType Ty)
524  : DestroyNRVOVariable<DestroyNRVOVariableC>(addr, NRVOFlag), Ty(Ty) {}
525 
526  QualType Ty;
527 
528  void emitDestructorCall(CodeGenFunction &CGF) {
529  CGF.destroyNonTrivialCStruct(CGF, Loc, Ty);
530  }
531  };
532 
533  struct CallStackRestore final : EHScopeStack::Cleanup {
534  Address Stack;
535  CallStackRestore(Address Stack) : Stack(Stack) {}
536  void Emit(CodeGenFunction &CGF, Flags flags) override {
537  llvm::Value *V = CGF.Builder.CreateLoad(Stack);
538  llvm::Value *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore);
539  CGF.Builder.CreateCall(F, V);
540  }
541  };
542 
543  struct ExtendGCLifetime final : EHScopeStack::Cleanup {
544  const VarDecl &Var;
545  ExtendGCLifetime(const VarDecl *var) : Var(*var) {}
546 
547  void Emit(CodeGenFunction &CGF, Flags flags) override {
548  // Compute the address of the local variable, in case it's a
549  // byref or something.
550  DeclRefExpr DRE(CGF.getContext(), const_cast<VarDecl *>(&Var), false,
551  Var.getType(), VK_LValue, SourceLocation());
552  llvm::Value *value = CGF.EmitLoadOfScalar(CGF.EmitDeclRefLValue(&DRE),
553  SourceLocation());
554  CGF.EmitExtendGCLifetime(value);
555  }
556  };
557 
558  struct CallCleanupFunction final : EHScopeStack::Cleanup {
559  llvm::Constant *CleanupFn;
560  const CGFunctionInfo &FnInfo;
561  const VarDecl &Var;
562 
563  CallCleanupFunction(llvm::Constant *CleanupFn, const CGFunctionInfo *Info,
564  const VarDecl *Var)
565  : CleanupFn(CleanupFn), FnInfo(*Info), Var(*Var) {}
566 
567  void Emit(CodeGenFunction &CGF, Flags flags) override {
568  DeclRefExpr DRE(CGF.getContext(), const_cast<VarDecl *>(&Var), false,
569  Var.getType(), VK_LValue, SourceLocation());
570  // Compute the address of the local variable, in case it's a byref
571  // or something.
572  llvm::Value *Addr = CGF.EmitDeclRefLValue(&DRE).getPointer();
573 
574  // In some cases, the type of the function argument will be different from
575  // the type of the pointer. An example of this is
576  // void f(void* arg);
577  // __attribute__((cleanup(f))) void *g;
578  //
579  // To fix this we insert a bitcast here.
580  QualType ArgTy = FnInfo.arg_begin()->type;
581  llvm::Value *Arg =
582  CGF.Builder.CreateBitCast(Addr, CGF.ConvertType(ArgTy));
583 
584  CallArgList Args;
585  Args.add(RValue::get(Arg),
586  CGF.getContext().getPointerType(Var.getType()));
587  auto Callee = CGCallee::forDirect(CleanupFn);
588  CGF.EmitCall(FnInfo, Callee, ReturnValueSlot(), Args);
589  }
590  };
591 } // end anonymous namespace
592 
593 /// EmitAutoVarWithLifetime - Does the setup required for an automatic
594 /// variable with lifetime.
595 static void EmitAutoVarWithLifetime(CodeGenFunction &CGF, const VarDecl &var,
596  Address addr,
597  Qualifiers::ObjCLifetime lifetime) {
598  switch (lifetime) {
600  llvm_unreachable("present but none");
601 
603  // nothing to do
604  break;
605 
606  case Qualifiers::OCL_Strong: {
607  CodeGenFunction::Destroyer *destroyer =
608  (var.hasAttr<ObjCPreciseLifetimeAttr>()
611 
612  CleanupKind cleanupKind = CGF.getARCCleanupKind();
613  CGF.pushDestroy(cleanupKind, addr, var.getType(), destroyer,
614  cleanupKind & EHCleanup);
615  break;
616  }
618  // nothing to do
619  break;
620 
622  // __weak objects always get EH cleanups; otherwise, exceptions
623  // could cause really nasty crashes instead of mere leaks.
624  CGF.pushDestroy(NormalAndEHCleanup, addr, var.getType(),
626  /*useEHCleanup*/ true);
627  break;
628  }
629 }
630 
631 static bool isAccessedBy(const VarDecl &var, const Stmt *s) {
632  if (const Expr *e = dyn_cast<Expr>(s)) {
633  // Skip the most common kinds of expressions that make
634  // hierarchy-walking expensive.
635  s = e = e->IgnoreParenCasts();
636 
637  if (const DeclRefExpr *ref = dyn_cast<DeclRefExpr>(e))
638  return (ref->getDecl() == &var);
639  if (const BlockExpr *be = dyn_cast<BlockExpr>(e)) {
640  const BlockDecl *block = be->getBlockDecl();
641  for (const auto &I : block->captures()) {
642  if (I.getVariable() == &var)
643  return true;
644  }
645  }
646  }
647 
648  for (const Stmt *SubStmt : s->children())
649  // SubStmt might be null; as in missing decl or conditional of an if-stmt.
650  if (SubStmt && isAccessedBy(var, SubStmt))
651  return true;
652 
653  return false;
654 }
655 
656 static bool isAccessedBy(const ValueDecl *decl, const Expr *e) {
657  if (!decl) return false;
658  if (!isa<VarDecl>(decl)) return false;
659  const VarDecl *var = cast<VarDecl>(decl);
660  return isAccessedBy(*var, e);
661 }
662 
664  const LValue &destLV, const Expr *init) {
665  bool needsCast = false;
666 
667  while (auto castExpr = dyn_cast<CastExpr>(init->IgnoreParens())) {
668  switch (castExpr->getCastKind()) {
669  // Look through casts that don't require representation changes.
670  case CK_NoOp:
671  case CK_BitCast:
672  case CK_BlockPointerToObjCPointerCast:
673  needsCast = true;
674  break;
675 
676  // If we find an l-value to r-value cast from a __weak variable,
677  // emit this operation as a copy or move.
678  case CK_LValueToRValue: {
679  const Expr *srcExpr = castExpr->getSubExpr();
680  if (srcExpr->getType().getObjCLifetime() != Qualifiers::OCL_Weak)
681  return false;
682 
683  // Emit the source l-value.
684  LValue srcLV = CGF.EmitLValue(srcExpr);
685 
686  // Handle a formal type change to avoid asserting.
687  auto srcAddr = srcLV.getAddress();
688  if (needsCast) {
689  srcAddr = CGF.Builder.CreateElementBitCast(srcAddr,
690  destLV.getAddress().getElementType());
691  }
692 
693  // If it was an l-value, use objc_copyWeak.
694  if (srcExpr->getValueKind() == VK_LValue) {
695  CGF.EmitARCCopyWeak(destLV.getAddress(), srcAddr);
696  } else {
697  assert(srcExpr->getValueKind() == VK_XValue);
698  CGF.EmitARCMoveWeak(destLV.getAddress(), srcAddr);
699  }
700  return true;
701  }
702 
703  // Stop at anything else.
704  default:
705  return false;
706  }
707 
708  init = castExpr->getSubExpr();
709  }
710  return false;
711 }
712 
714  LValue &lvalue,
715  const VarDecl *var) {
716  lvalue.setAddress(CGF.emitBlockByrefAddress(lvalue.getAddress(), var));
717 }
718 
720  SourceLocation Loc) {
721  if (!SanOpts.has(SanitizerKind::NullabilityAssign))
722  return;
723 
724  auto Nullability = LHS.getType()->getNullability(getContext());
726  return;
727 
728  // Check if the right hand side of the assignment is nonnull, if the left
729  // hand side must be nonnull.
730  SanitizerScope SanScope(this);
731  llvm::Value *IsNotNull = Builder.CreateIsNotNull(RHS);
732  llvm::Constant *StaticData[] = {
734  llvm::ConstantInt::get(Int8Ty, 0), // The LogAlignment info is unused.
735  llvm::ConstantInt::get(Int8Ty, TCK_NonnullAssign)};
736  EmitCheck({{IsNotNull, SanitizerKind::NullabilityAssign}},
737  SanitizerHandler::TypeMismatch, StaticData, RHS);
738 }
739 
740 void CodeGenFunction::EmitScalarInit(const Expr *init, const ValueDecl *D,
741  LValue lvalue, bool capturedByInit) {
742  Qualifiers::ObjCLifetime lifetime = lvalue.getObjCLifetime();
743  if (!lifetime) {
744  llvm::Value *value = EmitScalarExpr(init);
745  if (capturedByInit)
746  drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
747  EmitNullabilityCheck(lvalue, value, init->getExprLoc());
748  EmitStoreThroughLValue(RValue::get(value), lvalue, true);
749  return;
750  }
751 
752  if (const CXXDefaultInitExpr *DIE = dyn_cast<CXXDefaultInitExpr>(init))
753  init = DIE->getExpr();
754 
755  // If we're emitting a value with lifetime, we have to do the
756  // initialization *before* we leave the cleanup scopes.
757  if (const FullExpr *fe = dyn_cast<FullExpr>(init)) {
759  init = fe->getSubExpr();
760  }
762 
763  // We have to maintain the illusion that the variable is
764  // zero-initialized. If the variable might be accessed in its
765  // initializer, zero-initialize before running the initializer, then
766  // actually perform the initialization with an assign.
767  bool accessedByInit = false;
768  if (lifetime != Qualifiers::OCL_ExplicitNone)
769  accessedByInit = (capturedByInit || isAccessedBy(D, init));
770  if (accessedByInit) {
771  LValue tempLV = lvalue;
772  // Drill down to the __block object if necessary.
773  if (capturedByInit) {
774  // We can use a simple GEP for this because it can't have been
775  // moved yet.
777  cast<VarDecl>(D),
778  /*follow*/ false));
779  }
780 
781  auto ty = cast<llvm::PointerType>(tempLV.getAddress().getElementType());
782  llvm::Value *zero = CGM.getNullPointer(ty, tempLV.getType());
783 
784  // If __weak, we want to use a barrier under certain conditions.
785  if (lifetime == Qualifiers::OCL_Weak)
786  EmitARCInitWeak(tempLV.getAddress(), zero);
787 
788  // Otherwise just do a simple store.
789  else
790  EmitStoreOfScalar(zero, tempLV, /* isInitialization */ true);
791  }
792 
793  // Emit the initializer.
794  llvm::Value *value = nullptr;
795 
796  switch (lifetime) {
798  llvm_unreachable("present but none");
799 
800  case Qualifiers::OCL_Strong: {
801  if (!D || !isa<VarDecl>(D) || !cast<VarDecl>(D)->isARCPseudoStrong()) {
802  value = EmitARCRetainScalarExpr(init);
803  break;
804  }
805  // If D is pseudo-strong, treat it like __unsafe_unretained here. This means
806  // that we omit the retain, and causes non-autoreleased return values to be
807  // immediately released.
808  LLVM_FALLTHROUGH;
809  }
810 
812  value = EmitARCUnsafeUnretainedScalarExpr(init);
813  break;
814 
815  case Qualifiers::OCL_Weak: {
816  // If it's not accessed by the initializer, try to emit the
817  // initialization with a copy or move.
818  if (!accessedByInit && tryEmitARCCopyWeakInit(*this, lvalue, init)) {
819  return;
820  }
821 
822  // No way to optimize a producing initializer into this. It's not
823  // worth optimizing for, because the value will immediately
824  // disappear in the common case.
825  value = EmitScalarExpr(init);
826 
827  if (capturedByInit) drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
828  if (accessedByInit)
829  EmitARCStoreWeak(lvalue.getAddress(), value, /*ignored*/ true);
830  else
831  EmitARCInitWeak(lvalue.getAddress(), value);
832  return;
833  }
834 
837  break;
838  }
839 
840  if (capturedByInit) drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
841 
842  EmitNullabilityCheck(lvalue, value, init->getExprLoc());
843 
844  // If the variable might have been accessed by its initializer, we
845  // might have to initialize with a barrier. We have to do this for
846  // both __weak and __strong, but __weak got filtered out above.
847  if (accessedByInit && lifetime == Qualifiers::OCL_Strong) {
848  llvm::Value *oldValue = EmitLoadOfScalar(lvalue, init->getExprLoc());
849  EmitStoreOfScalar(value, lvalue, /* isInitialization */ true);
851  return;
852  }
853 
854  EmitStoreOfScalar(value, lvalue, /* isInitialization */ true);
855 }
856 
857 /// Decide whether we can emit the non-zero parts of the specified initializer
858 /// with equal or fewer than NumStores scalar stores.
859 static bool canEmitInitWithFewStoresAfterBZero(llvm::Constant *Init,
860  unsigned &NumStores) {
861  // Zero and Undef never requires any extra stores.
862  if (isa<llvm::ConstantAggregateZero>(Init) ||
863  isa<llvm::ConstantPointerNull>(Init) ||
864  isa<llvm::UndefValue>(Init))
865  return true;
866  if (isa<llvm::ConstantInt>(Init) || isa<llvm::ConstantFP>(Init) ||
867  isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
868  isa<llvm::ConstantExpr>(Init))
869  return Init->isNullValue() || NumStores--;
870 
871  // See if we can emit each element.
872  if (isa<llvm::ConstantArray>(Init) || isa<llvm::ConstantStruct>(Init)) {
873  for (unsigned i = 0, e = Init->getNumOperands(); i != e; ++i) {
874  llvm::Constant *Elt = cast<llvm::Constant>(Init->getOperand(i));
875  if (!canEmitInitWithFewStoresAfterBZero(Elt, NumStores))
876  return false;
877  }
878  return true;
879  }
880 
881  if (llvm::ConstantDataSequential *CDS =
882  dyn_cast<llvm::ConstantDataSequential>(Init)) {
883  for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
884  llvm::Constant *Elt = CDS->getElementAsConstant(i);
885  if (!canEmitInitWithFewStoresAfterBZero(Elt, NumStores))
886  return false;
887  }
888  return true;
889  }
890 
891  // Anything else is hard and scary.
892  return false;
893 }
894 
895 /// For inits that canEmitInitWithFewStoresAfterBZero returned true for, emit
896 /// the scalar stores that would be required.
898  llvm::Constant *Init, Address Loc,
899  bool isVolatile, CGBuilderTy &Builder) {
900  assert(!Init->isNullValue() && !isa<llvm::UndefValue>(Init) &&
901  "called emitStoresForInitAfterBZero for zero or undef value.");
902 
903  if (isa<llvm::ConstantInt>(Init) || isa<llvm::ConstantFP>(Init) ||
904  isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
905  isa<llvm::ConstantExpr>(Init)) {
906  Builder.CreateStore(Init, Loc, isVolatile);
907  return;
908  }
909 
910  if (llvm::ConstantDataSequential *CDS =
911  dyn_cast<llvm::ConstantDataSequential>(Init)) {
912  for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
913  llvm::Constant *Elt = CDS->getElementAsConstant(i);
914 
915  // If necessary, get a pointer to the element and emit it.
916  if (!Elt->isNullValue() && !isa<llvm::UndefValue>(Elt))
918  CGM, Elt,
919  Builder.CreateConstInBoundsGEP2_32(Loc, 0, i, CGM.getDataLayout()),
920  isVolatile, Builder);
921  }
922  return;
923  }
924 
925  assert((isa<llvm::ConstantStruct>(Init) || isa<llvm::ConstantArray>(Init)) &&
926  "Unknown value type!");
927 
928  for (unsigned i = 0, e = Init->getNumOperands(); i != e; ++i) {
929  llvm::Constant *Elt = cast<llvm::Constant>(Init->getOperand(i));
930 
931  // If necessary, get a pointer to the element and emit it.
932  if (!Elt->isNullValue() && !isa<llvm::UndefValue>(Elt))
934  CGM, Elt,
935  Builder.CreateConstInBoundsGEP2_32(Loc, 0, i, CGM.getDataLayout()),
936  isVolatile, Builder);
937  }
938 }
939 
940 /// Decide whether we should use bzero plus some stores to initialize a local
941 /// variable instead of using a memcpy from a constant global. It is beneficial
942 /// to use bzero if the global is all zeros, or mostly zeros and large.
943 static bool shouldUseBZeroPlusStoresToInitialize(llvm::Constant *Init,
944  uint64_t GlobalSize) {
945  // If a global is all zeros, always use a bzero.
946  if (isa<llvm::ConstantAggregateZero>(Init)) return true;
947 
948  // If a non-zero global is <= 32 bytes, always use a memcpy. If it is large,
949  // do it if it will require 6 or fewer scalar stores.
950  // TODO: Should budget depends on the size? Avoiding a large global warrants
951  // plopping in more stores.
952  unsigned StoreBudget = 6;
953  uint64_t SizeLimit = 32;
954 
955  return GlobalSize > SizeLimit &&
956  canEmitInitWithFewStoresAfterBZero(Init, StoreBudget);
957 }
958 
959 /// Decide whether we should use memset to initialize a local variable instead
960 /// of using a memcpy from a constant global. Assumes we've already decided to
961 /// not user bzero.
962 /// FIXME We could be more clever, as we are for bzero above, and generate
963 /// memset followed by stores. It's unclear that's worth the effort.
964 static llvm::Value *shouldUseMemSetToInitialize(llvm::Constant *Init,
965  uint64_t GlobalSize) {
966  uint64_t SizeLimit = 32;
967  if (GlobalSize <= SizeLimit)
968  return nullptr;
969  return llvm::isBytewiseValue(Init);
970 }
971 
972 static llvm::Constant *patternFor(CodeGenModule &CGM, llvm::Type *Ty) {
973  // The following value is a guaranteed unmappable pointer value and has a
974  // repeated byte-pattern which makes it easier to synthesize. We use it for
975  // pointers as well as integers so that aggregates are likely to be
976  // initialized with this repeated value.
977  constexpr uint64_t LargeValue = 0xAAAAAAAAAAAAAAAAull;
978  // For 32-bit platforms it's a bit trickier because, across systems, only the
979  // zero page can reasonably be expected to be unmapped, and even then we need
980  // a very low address. We use a smaller value, and that value sadly doesn't
981  // have a repeated byte-pattern. We don't use it for integers.
982  constexpr uint32_t SmallValue = 0x000000AA;
983  // Floating-point values are initialized as NaNs because they propagate. Using
984  // a repeated byte pattern means that it will be easier to initialize
985  // all-floating-point aggregates and arrays with memset. Further, aggregates
986  // which mix integral and a few floats might also initialize with memset
987  // followed by a handful of stores for the floats. Using fairly unique NaNs
988  // also means they'll be easier to distinguish in a crash.
989  constexpr bool NegativeNaN = true;
990  constexpr uint64_t NaNPayload = 0xFFFFFFFFFFFFFFFFull;
991  if (Ty->isIntOrIntVectorTy()) {
992  unsigned BitWidth = cast<llvm::IntegerType>(
993  Ty->isVectorTy() ? Ty->getVectorElementType() : Ty)
994  ->getBitWidth();
995  if (BitWidth <= 64)
996  return llvm::ConstantInt::get(Ty, LargeValue);
997  return llvm::ConstantInt::get(
998  Ty, llvm::APInt::getSplat(BitWidth, llvm::APInt(64, LargeValue)));
999  }
1000  if (Ty->isPtrOrPtrVectorTy()) {
1001  auto *PtrTy = cast<llvm::PointerType>(
1002  Ty->isVectorTy() ? Ty->getVectorElementType() : Ty);
1003  unsigned PtrWidth = CGM.getContext().getTargetInfo().getPointerWidth(
1004  PtrTy->getAddressSpace());
1005  llvm::Type *IntTy = llvm::IntegerType::get(CGM.getLLVMContext(), PtrWidth);
1006  uint64_t IntValue;
1007  switch (PtrWidth) {
1008  default:
1009  llvm_unreachable("pattern initialization of unsupported pointer width");
1010  case 64:
1011  IntValue = LargeValue;
1012  break;
1013  case 32:
1014  IntValue = SmallValue;
1015  break;
1016  }
1017  auto *Int = llvm::ConstantInt::get(IntTy, IntValue);
1018  return llvm::ConstantExpr::getIntToPtr(Int, PtrTy);
1019  }
1020  if (Ty->isFPOrFPVectorTy()) {
1021  unsigned BitWidth = llvm::APFloat::semanticsSizeInBits(
1022  (Ty->isVectorTy() ? Ty->getVectorElementType() : Ty)
1023  ->getFltSemantics());
1024  llvm::APInt Payload(64, NaNPayload);
1025  if (BitWidth >= 64)
1026  Payload = llvm::APInt::getSplat(BitWidth, Payload);
1027  return llvm::ConstantFP::getQNaN(Ty, NegativeNaN, &Payload);
1028  }
1029  if (Ty->isArrayTy()) {
1030  // Note: this doesn't touch tail padding (at the end of an object, before
1031  // the next array object). It is instead handled by replaceUndef.
1032  auto *ArrTy = cast<llvm::ArrayType>(Ty);
1034  ArrTy->getNumElements(), patternFor(CGM, ArrTy->getElementType()));
1035  return llvm::ConstantArray::get(ArrTy, Element);
1036  }
1037 
1038  // Note: this doesn't touch struct padding. It will initialize as much union
1039  // padding as is required for the largest type in the union. Padding is
1040  // instead handled by replaceUndef. Stores to structs with volatile members
1041  // don't have a volatile qualifier when initialized according to C++. This is
1042  // fine because stack-based volatiles don't really have volatile semantics
1043  // anyways, and the initialization shouldn't be observable.
1044  auto *StructTy = cast<llvm::StructType>(Ty);
1045  llvm::SmallVector<llvm::Constant *, 8> Struct(StructTy->getNumElements());
1046  for (unsigned El = 0; El != Struct.size(); ++El)
1047  Struct[El] = patternFor(CGM, StructTy->getElementType(El));
1048  return llvm::ConstantStruct::get(StructTy, Struct);
1049 }
1050 
1053  llvm::Constant *Constant,
1054  CharUnits Align) {
1055  auto FunctionName = [&](const DeclContext *DC) -> std::string {
1056  if (const auto *FD = dyn_cast<FunctionDecl>(DC)) {
1057  if (const auto *CC = dyn_cast<CXXConstructorDecl>(FD))
1058  return CC->getNameAsString();
1059  if (const auto *CD = dyn_cast<CXXDestructorDecl>(FD))
1060  return CD->getNameAsString();
1061  return CGM.getMangledName(FD);
1062  } else if (const auto *OM = dyn_cast<ObjCMethodDecl>(DC)) {
1063  return OM->getNameAsString();
1064  } else if (isa<BlockDecl>(DC)) {
1065  return "<block>";
1066  } else if (isa<CapturedDecl>(DC)) {
1067  return "<captured>";
1068  } else {
1069  llvm::llvm_unreachable_internal("expected a function or method");
1070  }
1071  };
1072 
1073  auto *Ty = Constant->getType();
1074  bool isConstant = true;
1075  llvm::GlobalVariable *InsertBefore = nullptr;
1076  unsigned AS = CGM.getContext().getTargetAddressSpace(
1078  llvm::GlobalVariable *GV = new llvm::GlobalVariable(
1079  CGM.getModule(), Ty, isConstant, llvm::GlobalValue::PrivateLinkage,
1080  Constant,
1081  "__const." + FunctionName(D.getParentFunctionOrMethod()) + "." +
1082  D.getName(),
1083  InsertBefore, llvm::GlobalValue::NotThreadLocal, AS);
1084  GV->setAlignment(Align.getQuantity());
1085  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1086 
1087  Address SrcPtr = Address(GV, Align);
1088  llvm::Type *BP = llvm::PointerType::getInt8PtrTy(CGM.getLLVMContext(), AS);
1089  if (SrcPtr.getType() != BP)
1090  SrcPtr = Builder.CreateBitCast(SrcPtr, BP);
1091  return SrcPtr;
1092 }
1093 
1095  Address Loc, bool isVolatile,
1097  llvm::Constant *constant) {
1098  auto *Ty = constant->getType();
1099  bool isScalar = Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy() ||
1100  Ty->isFPOrFPVectorTy();
1101  if (isScalar) {
1102  Builder.CreateStore(constant, Loc, isVolatile);
1103  return;
1104  }
1105 
1106  auto *Int8Ty = llvm::IntegerType::getInt8Ty(CGM.getLLVMContext());
1107  auto *IntPtrTy = CGM.getDataLayout().getIntPtrType(CGM.getLLVMContext());
1108 
1109  // If the initializer is all or mostly the same, codegen with bzero / memset
1110  // then do a few stores afterward.
1111  uint64_t ConstantSize = CGM.getDataLayout().getTypeAllocSize(Ty);
1112  auto *SizeVal = llvm::ConstantInt::get(IntPtrTy, ConstantSize);
1113  if (shouldUseBZeroPlusStoresToInitialize(constant, ConstantSize)) {
1114  Builder.CreateMemSet(Loc, llvm::ConstantInt::get(Int8Ty, 0), SizeVal,
1115  isVolatile);
1116 
1117  bool valueAlreadyCorrect =
1118  constant->isNullValue() || isa<llvm::UndefValue>(constant);
1119  if (!valueAlreadyCorrect) {
1120  Loc = Builder.CreateBitCast(Loc, Ty->getPointerTo(Loc.getAddressSpace()));
1121  emitStoresForInitAfterBZero(CGM, constant, Loc, isVolatile, Builder);
1122  }
1123  return;
1124  }
1125 
1126  llvm::Value *Pattern = shouldUseMemSetToInitialize(constant, ConstantSize);
1127  if (Pattern) {
1128  uint64_t Value = 0x00;
1129  if (!isa<llvm::UndefValue>(Pattern)) {
1130  const llvm::APInt &AP = cast<llvm::ConstantInt>(Pattern)->getValue();
1131  assert(AP.getBitWidth() <= 8);
1132  Value = AP.getLimitedValue();
1133  }
1134  Builder.CreateMemSet(Loc, llvm::ConstantInt::get(Int8Ty, Value), SizeVal,
1135  isVolatile);
1136  return;
1137  }
1138 
1139  Builder.CreateMemCpy(
1140  Loc,
1141  createUnnamedGlobalFrom(CGM, D, Builder, constant, Loc.getAlignment()),
1142  SizeVal, isVolatile);
1143 }
1144 
1146  Address Loc, bool isVolatile,
1147  CGBuilderTy &Builder) {
1148  llvm::Type *ElTy = Loc.getElementType();
1149  llvm::Constant *constant = llvm::Constant::getNullValue(ElTy);
1150  emitStoresForConstant(CGM, D, Loc, isVolatile, Builder, constant);
1151 }
1152 
1154  Address Loc, bool isVolatile,
1155  CGBuilderTy &Builder) {
1156  llvm::Type *ElTy = Loc.getElementType();
1157  llvm::Constant *constant = patternFor(CGM, ElTy);
1158  assert(!isa<llvm::UndefValue>(constant));
1159  emitStoresForConstant(CGM, D, Loc, isVolatile, Builder, constant);
1160 }
1161 
1162 static bool containsUndef(llvm::Constant *constant) {
1163  auto *Ty = constant->getType();
1164  if (isa<llvm::UndefValue>(constant))
1165  return true;
1166  if (Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy())
1167  for (llvm::Use &Op : constant->operands())
1168  if (containsUndef(cast<llvm::Constant>(Op)))
1169  return true;
1170  return false;
1171 }
1172 
1173 static llvm::Constant *replaceUndef(llvm::Constant *constant) {
1174  // FIXME: when doing pattern initialization, replace undef with 0xAA instead.
1175  // FIXME: also replace padding between values by creating a new struct type
1176  // which has no padding.
1177  auto *Ty = constant->getType();
1178  if (isa<llvm::UndefValue>(constant))
1179  return llvm::Constant::getNullValue(Ty);
1180  if (!(Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()))
1181  return constant;
1182  if (!containsUndef(constant))
1183  return constant;
1184  llvm::SmallVector<llvm::Constant *, 8> Values(constant->getNumOperands());
1185  for (unsigned Op = 0, NumOp = constant->getNumOperands(); Op != NumOp; ++Op) {
1186  auto *OpValue = cast<llvm::Constant>(constant->getOperand(Op));
1187  Values[Op] = replaceUndef(OpValue);
1188  }
1189  if (Ty->isStructTy())
1190  return llvm::ConstantStruct::get(cast<llvm::StructType>(Ty), Values);
1191  if (Ty->isArrayTy())
1192  return llvm::ConstantArray::get(cast<llvm::ArrayType>(Ty), Values);
1193  assert(Ty->isVectorTy());
1194  return llvm::ConstantVector::get(Values);
1195 }
1196 
1197 /// EmitAutoVarDecl - Emit code and set up an entry in LocalDeclMap for a
1198 /// variable declaration with auto, register, or no storage class specifier.
1199 /// These turn into simple stack objects, or GlobalValues depending on target.
1201  AutoVarEmission emission = EmitAutoVarAlloca(D);
1202  EmitAutoVarInit(emission);
1203  EmitAutoVarCleanups(emission);
1204 }
1205 
1206 /// Emit a lifetime.begin marker if some criteria are satisfied.
1207 /// \return a pointer to the temporary size Value if a marker was emitted, null
1208 /// otherwise
1210  llvm::Value *Addr) {
1211  if (!ShouldEmitLifetimeMarkers)
1212  return nullptr;
1213 
1214  assert(Addr->getType()->getPointerAddressSpace() ==
1215  CGM.getDataLayout().getAllocaAddrSpace() &&
1216  "Pointer should be in alloca address space");
1217  llvm::Value *SizeV = llvm::ConstantInt::get(Int64Ty, Size);
1218  Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
1219  llvm::CallInst *C =
1220  Builder.CreateCall(CGM.getLLVMLifetimeStartFn(), {SizeV, Addr});
1221  C->setDoesNotThrow();
1222  return SizeV;
1223 }
1224 
1226  assert(Addr->getType()->getPointerAddressSpace() ==
1227  CGM.getDataLayout().getAllocaAddrSpace() &&
1228  "Pointer should be in alloca address space");
1229  Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
1230  llvm::CallInst *C =
1231  Builder.CreateCall(CGM.getLLVMLifetimeEndFn(), {Size, Addr});
1232  C->setDoesNotThrow();
1233 }
1234 
1236  CGDebugInfo *DI, const VarDecl &D, bool EmitDebugInfo) {
1237  // For each dimension stores its QualType and corresponding
1238  // size-expression Value.
1240  SmallVector<IdentifierInfo *, 4> VLAExprNames;
1241 
1242  // Break down the array into individual dimensions.
1243  QualType Type1D = D.getType();
1244  while (getContext().getAsVariableArrayType(Type1D)) {
1245  auto VlaSize = getVLAElements1D(Type1D);
1246  if (auto *C = dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))
1247  Dimensions.emplace_back(C, Type1D.getUnqualifiedType());
1248  else {
1249  // Generate a locally unique name for the size expression.
1250  Twine Name = Twine("__vla_expr") + Twine(VLAExprCounter++);
1251  SmallString<12> Buffer;
1252  StringRef NameRef = Name.toStringRef(Buffer);
1253  auto &Ident = getContext().Idents.getOwn(NameRef);
1254  VLAExprNames.push_back(&Ident);
1255  auto SizeExprAddr =
1256  CreateDefaultAlignTempAlloca(VlaSize.NumElts->getType(), NameRef);
1257  Builder.CreateStore(VlaSize.NumElts, SizeExprAddr);
1258  Dimensions.emplace_back(SizeExprAddr.getPointer(),
1259  Type1D.getUnqualifiedType());
1260  }
1261  Type1D = VlaSize.Type;
1262  }
1263 
1264  if (!EmitDebugInfo)
1265  return;
1266 
1267  // Register each dimension's size-expression with a DILocalVariable,
1268  // so that it can be used by CGDebugInfo when instantiating a DISubrange
1269  // to describe this array.
1270  unsigned NameIdx = 0;
1271  for (auto &VlaSize : Dimensions) {
1272  llvm::Metadata *MD;
1273  if (auto *C = dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))
1274  MD = llvm::ConstantAsMetadata::get(C);
1275  else {
1276  // Create an artificial VarDecl to generate debug info for.
1277  IdentifierInfo *NameIdent = VLAExprNames[NameIdx++];
1278  auto VlaExprTy = VlaSize.NumElts->getType()->getPointerElementType();
1279  auto QT = getContext().getIntTypeForBitwidth(
1280  VlaExprTy->getScalarSizeInBits(), false);
1281  auto *ArtificialDecl = VarDecl::Create(
1282  getContext(), const_cast<DeclContext *>(D.getDeclContext()),
1283  D.getLocation(), D.getLocation(), NameIdent, QT,
1285  ArtificialDecl->setImplicit();
1286 
1287  MD = DI->EmitDeclareOfAutoVariable(ArtificialDecl, VlaSize.NumElts,
1288  Builder);
1289  }
1290  assert(MD && "No Size expression debug node created");
1291  DI->registerVLASizeExpression(VlaSize.Type, MD);
1292  }
1293 }
1294 
1295 /// EmitAutoVarAlloca - Emit the alloca and debug information for a
1296 /// local variable. Does not emit initialization or destruction.
1299  QualType Ty = D.getType();
1300  assert(
1301  Ty.getAddressSpace() == LangAS::Default ||
1302  (Ty.getAddressSpace() == LangAS::opencl_private && getLangOpts().OpenCL));
1303 
1304  AutoVarEmission emission(D);
1305 
1306  bool isEscapingByRef = D.isEscapingByref();
1307  emission.IsEscapingByRef = isEscapingByRef;
1308 
1309  CharUnits alignment = getContext().getDeclAlign(&D);
1310 
1311  // If the type is variably-modified, emit all the VLA sizes for it.
1312  if (Ty->isVariablyModifiedType())
1314 
1315  auto *DI = getDebugInfo();
1316  bool EmitDebugInfo = DI && CGM.getCodeGenOpts().getDebugInfo() >=
1318 
1319  Address address = Address::invalid();
1320  Address AllocaAddr = Address::invalid();
1321  if (Ty->isConstantSizeType()) {
1322  bool NRVO = getLangOpts().ElideConstructors &&
1323  D.isNRVOVariable();
1324 
1325  // If this value is an array or struct with a statically determinable
1326  // constant initializer, there are optimizations we can do.
1327  //
1328  // TODO: We should constant-evaluate the initializer of any variable,
1329  // as long as it is initialized by a constant expression. Currently,
1330  // isConstantInitializer produces wrong answers for structs with
1331  // reference or bitfield members, and a few other cases, and checking
1332  // for POD-ness protects us from some of these.
1333  if (D.getInit() && (Ty->isArrayType() || Ty->isRecordType()) &&
1334  (D.isConstexpr() ||
1335  ((Ty.isPODType(getContext()) ||
1337  D.getInit()->isConstantInitializer(getContext(), false)))) {
1338 
1339  // If the variable's a const type, and it's neither an NRVO
1340  // candidate nor a __block variable and has no mutable members,
1341  // emit it as a global instead.
1342  // Exception is if a variable is located in non-constant address space
1343  // in OpenCL.
1344  if ((!getLangOpts().OpenCL ||
1346  (CGM.getCodeGenOpts().MergeAllConstants && !NRVO &&
1347  !isEscapingByRef && CGM.isTypeConstant(Ty, true))) {
1349 
1350  // Signal this condition to later callbacks.
1351  emission.Addr = Address::invalid();
1352  assert(emission.wasEmittedAsGlobal());
1353  return emission;
1354  }
1355 
1356  // Otherwise, tell the initialization code that we're in this case.
1357  emission.IsConstantAggregate = true;
1358  }
1359 
1360  // A normal fixed sized variable becomes an alloca in the entry block,
1361  // unless:
1362  // - it's an NRVO variable.
1363  // - we are compiling OpenMP and it's an OpenMP local variable.
1364 
1365  Address OpenMPLocalAddr =
1366  getLangOpts().OpenMP
1367  ? CGM.getOpenMPRuntime().getAddressOfLocalVariable(*this, &D)
1368  : Address::invalid();
1369  if (getLangOpts().OpenMP && OpenMPLocalAddr.isValid()) {
1370  address = OpenMPLocalAddr;
1371  } else if (NRVO) {
1372  // The named return value optimization: allocate this variable in the
1373  // return slot, so that we can elide the copy when returning this
1374  // variable (C++0x [class.copy]p34).
1375  address = ReturnValue;
1376 
1377  if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
1378  const auto *RD = RecordTy->getDecl();
1379  const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD);
1380  if ((CXXRD && !CXXRD->hasTrivialDestructor()) ||
1381  RD->isNonTrivialToPrimitiveDestroy()) {
1382  // Create a flag that is used to indicate when the NRVO was applied
1383  // to this variable. Set it to zero to indicate that NRVO was not
1384  // applied.
1385  llvm::Value *Zero = Builder.getFalse();
1386  Address NRVOFlag =
1387  CreateTempAlloca(Zero->getType(), CharUnits::One(), "nrvo");
1389  Builder.CreateStore(Zero, NRVOFlag);
1390 
1391  // Record the NRVO flag for this variable.
1392  NRVOFlags[&D] = NRVOFlag.getPointer();
1393  emission.NRVOFlag = NRVOFlag.getPointer();
1394  }
1395  }
1396  } else {
1397  CharUnits allocaAlignment;
1398  llvm::Type *allocaTy;
1399  if (isEscapingByRef) {
1400  auto &byrefInfo = getBlockByrefInfo(&D);
1401  allocaTy = byrefInfo.Type;
1402  allocaAlignment = byrefInfo.ByrefAlignment;
1403  } else {
1404  allocaTy = ConvertTypeForMem(Ty);
1405  allocaAlignment = alignment;
1406  }
1407 
1408  // Create the alloca. Note that we set the name separately from
1409  // building the instruction so that it's there even in no-asserts
1410  // builds.
1411  address = CreateTempAlloca(allocaTy, allocaAlignment, D.getName(),
1412  /*ArraySize=*/nullptr, &AllocaAddr);
1413 
1414  // Don't emit lifetime markers for MSVC catch parameters. The lifetime of
1415  // the catch parameter starts in the catchpad instruction, and we can't
1416  // insert code in those basic blocks.
1417  bool IsMSCatchParam =
1419 
1420  // Emit a lifetime intrinsic if meaningful. There's no point in doing this
1421  // if we don't have a valid insertion point (?).
1422  if (HaveInsertPoint() && !IsMSCatchParam) {
1423  // If there's a jump into the lifetime of this variable, its lifetime
1424  // gets broken up into several regions in IR, which requires more work
1425  // to handle correctly. For now, just omit the intrinsics; this is a
1426  // rare case, and it's better to just be conservatively correct.
1427  // PR28267.
1428  //
1429  // We have to do this in all language modes if there's a jump past the
1430  // declaration. We also have to do it in C if there's a jump to an
1431  // earlier point in the current block because non-VLA lifetimes begin as
1432  // soon as the containing block is entered, not when its variables
1433  // actually come into scope; suppressing the lifetime annotations
1434  // completely in this case is unnecessarily pessimistic, but again, this
1435  // is rare.
1436  if (!Bypasses.IsBypassed(&D) &&
1437  !(!getLangOpts().CPlusPlus && hasLabelBeenSeenInCurrentScope())) {
1438  uint64_t size = CGM.getDataLayout().getTypeAllocSize(allocaTy);
1439  emission.SizeForLifetimeMarkers =
1440  EmitLifetimeStart(size, AllocaAddr.getPointer());
1441  }
1442  } else {
1443  assert(!emission.useLifetimeMarkers());
1444  }
1445  }
1446  } else {
1448 
1449  if (!DidCallStackSave) {
1450  // Save the stack.
1451  Address Stack =
1452  CreateTempAlloca(Int8PtrTy, getPointerAlign(), "saved_stack");
1453 
1454  llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::stacksave);
1455  llvm::Value *V = Builder.CreateCall(F);
1456  Builder.CreateStore(V, Stack);
1457 
1458  DidCallStackSave = true;
1459 
1460  // Push a cleanup block and restore the stack there.
1461  // FIXME: in general circumstances, this should be an EH cleanup.
1463  }
1464 
1465  auto VlaSize = getVLASize(Ty);
1466  llvm::Type *llvmTy = ConvertTypeForMem(VlaSize.Type);
1467 
1468  // Allocate memory for the array.
1469  address = CreateTempAlloca(llvmTy, alignment, "vla", VlaSize.NumElts,
1470  &AllocaAddr);
1471 
1472  // If we have debug info enabled, properly describe the VLA dimensions for
1473  // this type by registering the vla size expression for each of the
1474  // dimensions.
1475  EmitAndRegisterVariableArrayDimensions(DI, D, EmitDebugInfo);
1476  }
1477 
1478  setAddrOfLocalVar(&D, address);
1479  emission.Addr = address;
1480  emission.AllocaAddr = AllocaAddr;
1481 
1482  // Emit debug info for local var declaration.
1483  if (EmitDebugInfo && HaveInsertPoint()) {
1484  DI->setLocation(D.getLocation());
1485  (void)DI->EmitDeclareOfAutoVariable(&D, address.getPointer(), Builder);
1486  }
1487 
1488  if (D.hasAttr<AnnotateAttr>())
1489  EmitVarAnnotations(&D, address.getPointer());
1490 
1491  // Make sure we call @llvm.lifetime.end.
1492  if (emission.useLifetimeMarkers())
1494  emission.getOriginalAllocatedAddress(),
1495  emission.getSizeForLifetimeMarkers());
1496 
1497  return emission;
1498 }
1499 
1500 static bool isCapturedBy(const VarDecl &, const Expr *);
1501 
1502 /// Determines whether the given __block variable is potentially
1503 /// captured by the given statement.
1504 static bool isCapturedBy(const VarDecl &Var, const Stmt *S) {
1505  if (const Expr *E = dyn_cast<Expr>(S))
1506  return isCapturedBy(Var, E);
1507  for (const Stmt *SubStmt : S->children())
1508  if (isCapturedBy(Var, SubStmt))
1509  return true;
1510  return false;
1511 }
1512 
1513 /// Determines whether the given __block variable is potentially
1514 /// captured by the given expression.
1515 static bool isCapturedBy(const VarDecl &Var, const Expr *E) {
1516  // Skip the most common kinds of expressions that make
1517  // hierarchy-walking expensive.
1518  E = E->IgnoreParenCasts();
1519 
1520  if (const BlockExpr *BE = dyn_cast<BlockExpr>(E)) {
1521  const BlockDecl *Block = BE->getBlockDecl();
1522  for (const auto &I : Block->captures()) {
1523  if (I.getVariable() == &Var)
1524  return true;
1525  }
1526 
1527  // No need to walk into the subexpressions.
1528  return false;
1529  }
1530 
1531  if (const StmtExpr *SE = dyn_cast<StmtExpr>(E)) {
1532  const CompoundStmt *CS = SE->getSubStmt();
1533  for (const auto *BI : CS->body())
1534  if (const auto *BIE = dyn_cast<Expr>(BI)) {
1535  if (isCapturedBy(Var, BIE))
1536  return true;
1537  }
1538  else if (const auto *DS = dyn_cast<DeclStmt>(BI)) {
1539  // special case declarations
1540  for (const auto *I : DS->decls()) {
1541  if (const auto *VD = dyn_cast<VarDecl>((I))) {
1542  const Expr *Init = VD->getInit();
1543  if (Init && isCapturedBy(Var, Init))
1544  return true;
1545  }
1546  }
1547  }
1548  else
1549  // FIXME. Make safe assumption assuming arbitrary statements cause capturing.
1550  // Later, provide code to poke into statements for capture analysis.
1551  return true;
1552  return false;
1553  }
1554 
1555  for (const Stmt *SubStmt : E->children())
1556  if (isCapturedBy(Var, SubStmt))
1557  return true;
1558 
1559  return false;
1560 }
1561 
1562 /// Determine whether the given initializer is trivial in the sense
1563 /// that it requires no code to be generated.
1565  if (!Init)
1566  return true;
1567 
1568  if (const CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init))
1569  if (CXXConstructorDecl *Constructor = Construct->getConstructor())
1570  if (Constructor->isTrivial() &&
1571  Constructor->isDefaultConstructor() &&
1572  !Construct->requiresZeroInitialization())
1573  return true;
1574 
1575  return false;
1576 }
1577 
1579  assert(emission.Variable && "emission was not valid!");
1580 
1581  // If this was emitted as a global constant, we're done.
1582  if (emission.wasEmittedAsGlobal()) return;
1583 
1584  const VarDecl &D = *emission.Variable;
1586  QualType type = D.getType();
1587 
1588  bool isVolatile = type.isVolatileQualified();
1589 
1590  // If this local has an initializer, emit it now.
1591  const Expr *Init = D.getInit();
1592 
1593  // If we are at an unreachable point, we don't need to emit the initializer
1594  // unless it contains a label.
1595  if (!HaveInsertPoint()) {
1596  if (!Init || !ContainsLabel(Init)) return;
1598  }
1599 
1600  // Initialize the structure of a __block variable.
1601  if (emission.IsEscapingByRef)
1602  emitByrefStructureInit(emission);
1603 
1604  // Initialize the variable here if it doesn't have a initializer and it is a
1605  // C struct that is non-trivial to initialize or an array containing such a
1606  // struct.
1607  if (!Init &&
1608  type.isNonTrivialToPrimitiveDefaultInitialize() ==
1610  LValue Dst = MakeAddrLValue(emission.getAllocatedAddress(), type);
1611  if (emission.IsEscapingByRef)
1612  drillIntoBlockVariable(*this, Dst, &D);
1614  return;
1615  }
1616 
1617  // Check whether this is a byref variable that's potentially
1618  // captured and moved by its own initializer. If so, we'll need to
1619  // emit the initializer first, then copy into the variable.
1620  bool capturedByInit =
1621  Init && emission.IsEscapingByRef && isCapturedBy(D, Init);
1622 
1623  Address Loc =
1624  capturedByInit ? emission.Addr : emission.getObjectAddress(*this);
1625 
1626  // Note: constexpr already initializes everything correctly.
1627  LangOptions::TrivialAutoVarInitKind trivialAutoVarInit =
1628  (D.isConstexpr()
1630  : (D.getAttr<UninitializedAttr>()
1632  : getContext().getLangOpts().getTrivialAutoVarInit()));
1633 
1634  auto initializeWhatIsTechnicallyUninitialized = [&]() {
1635  if (trivialAutoVarInit ==
1637  return;
1638 
1639  CharUnits Size = getContext().getTypeSizeInChars(type);
1640  if (!Size.isZero()) {
1641  switch (trivialAutoVarInit) {
1643  llvm_unreachable("Uninitialized handled above");
1645  emitStoresForZeroInit(CGM, D, Loc, isVolatile, Builder);
1646  break;
1648  emitStoresForPatternInit(CGM, D, Loc, isVolatile, Builder);
1649  break;
1650  }
1651  return;
1652  }
1653 
1654  // VLAs look zero-sized to getTypeInfo. We can't emit constant stores to
1655  // them, so emit a memcpy with the VLA size to initialize each element.
1656  // Technically zero-sized or negative-sized VLAs are undefined, and UBSan
1657  // will catch that code, but there exists code which generates zero-sized
1658  // VLAs. Be nice and initialize whatever they requested.
1659  const VariableArrayType *VlaType =
1660  dyn_cast_or_null<VariableArrayType>(getContext().getAsArrayType(type));
1661  if (!VlaType)
1662  return;
1663  auto VlaSize = getVLASize(VlaType);
1664  auto SizeVal = VlaSize.NumElts;
1665  CharUnits EltSize = getContext().getTypeSizeInChars(VlaSize.Type);
1666  switch (trivialAutoVarInit) {
1668  llvm_unreachable("Uninitialized handled above");
1669 
1671  if (!EltSize.isOne())
1672  SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(EltSize));
1673  Builder.CreateMemSet(Loc, llvm::ConstantInt::get(Int8Ty, 0), SizeVal,
1674  isVolatile);
1675  break;
1676 
1678  llvm::Type *ElTy = Loc.getElementType();
1679  llvm::Constant *Constant = patternFor(CGM, ElTy);
1680  CharUnits ConstantAlign = getContext().getTypeAlignInChars(VlaSize.Type);
1681  llvm::BasicBlock *SetupBB = createBasicBlock("vla-setup.loop");
1682  llvm::BasicBlock *LoopBB = createBasicBlock("vla-init.loop");
1683  llvm::BasicBlock *ContBB = createBasicBlock("vla-init.cont");
1684  llvm::Value *IsZeroSizedVLA = Builder.CreateICmpEQ(
1685  SizeVal, llvm::ConstantInt::get(SizeVal->getType(), 0),
1686  "vla.iszerosized");
1687  Builder.CreateCondBr(IsZeroSizedVLA, ContBB, SetupBB);
1688  EmitBlock(SetupBB);
1689  if (!EltSize.isOne())
1690  SizeVal = Builder.CreateNUWMul(SizeVal, CGM.getSize(EltSize));
1691  llvm::Value *BaseSizeInChars =
1692  llvm::ConstantInt::get(IntPtrTy, EltSize.getQuantity());
1693  Address Begin = Builder.CreateElementBitCast(Loc, Int8Ty, "vla.begin");
1694  llvm::Value *End =
1695  Builder.CreateInBoundsGEP(Begin.getPointer(), SizeVal, "vla.end");
1696  llvm::BasicBlock *OriginBB = Builder.GetInsertBlock();
1697  EmitBlock(LoopBB);
1698  llvm::PHINode *Cur = Builder.CreatePHI(Begin.getType(), 2, "vla.cur");
1699  Cur->addIncoming(Begin.getPointer(), OriginBB);
1700  CharUnits CurAlign = Loc.getAlignment().alignmentOfArrayElement(EltSize);
1702  Address(Cur, CurAlign),
1703  createUnnamedGlobalFrom(CGM, D, Builder, Constant, ConstantAlign),
1704  BaseSizeInChars, isVolatile);
1705  llvm::Value *Next =
1706  Builder.CreateInBoundsGEP(Int8Ty, Cur, BaseSizeInChars, "vla.next");
1707  llvm::Value *Done = Builder.CreateICmpEQ(Next, End, "vla-init.isdone");
1708  Builder.CreateCondBr(Done, ContBB, LoopBB);
1709  Cur->addIncoming(Next, LoopBB);
1710  EmitBlock(ContBB);
1711  } break;
1712  }
1713  };
1714 
1715  if (isTrivialInitializer(Init)) {
1716  initializeWhatIsTechnicallyUninitialized();
1717  return;
1718  }
1719 
1720  llvm::Constant *constant = nullptr;
1721  if (emission.IsConstantAggregate || D.isConstexpr()) {
1722  assert(!capturedByInit && "constant init contains a capturing block?");
1723  constant = ConstantEmitter(*this).tryEmitAbstractForInitializer(D);
1724  if (constant && trivialAutoVarInit !=
1726  constant = replaceUndef(constant);
1727  }
1728 
1729  if (!constant) {
1730  initializeWhatIsTechnicallyUninitialized();
1731  LValue lv = MakeAddrLValue(Loc, type);
1732  lv.setNonGC(true);
1733  return EmitExprAsInit(Init, &D, lv, capturedByInit);
1734  }
1735 
1736  if (!emission.IsConstantAggregate) {
1737  // For simple scalar/complex initialization, store the value directly.
1738  LValue lv = MakeAddrLValue(Loc, type);
1739  lv.setNonGC(true);
1740  return EmitStoreThroughLValue(RValue::get(constant), lv, true);
1741  }
1742 
1743  llvm::Type *BP = CGM.Int8Ty->getPointerTo(Loc.getAddressSpace());
1744  if (Loc.getType() != BP)
1745  Loc = Builder.CreateBitCast(Loc, BP);
1746 
1747  emitStoresForConstant(CGM, D, Loc, isVolatile, Builder, constant);
1748 }
1749 
1750 /// Emit an expression as an initializer for an object (variable, field, etc.)
1751 /// at the given location. The expression is not necessarily the normal
1752 /// initializer for the object, and the address is not necessarily
1753 /// its normal location.
1754 ///
1755 /// \param init the initializing expression
1756 /// \param D the object to act as if we're initializing
1757 /// \param loc the address to initialize; its type is a pointer
1758 /// to the LLVM mapping of the object's type
1759 /// \param alignment the alignment of the address
1760 /// \param capturedByInit true if \p D is a __block variable
1761 /// whose address is potentially changed by the initializer
1763  LValue lvalue, bool capturedByInit) {
1764  QualType type = D->getType();
1765 
1766  if (type->isReferenceType()) {
1767  RValue rvalue = EmitReferenceBindingToExpr(init);
1768  if (capturedByInit)
1769  drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
1770  EmitStoreThroughLValue(rvalue, lvalue, true);
1771  return;
1772  }
1773  switch (getEvaluationKind(type)) {
1774  case TEK_Scalar:
1775  EmitScalarInit(init, D, lvalue, capturedByInit);
1776  return;
1777  case TEK_Complex: {
1778  ComplexPairTy complex = EmitComplexExpr(init);
1779  if (capturedByInit)
1780  drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
1781  EmitStoreOfComplex(complex, lvalue, /*init*/ true);
1782  return;
1783  }
1784  case TEK_Aggregate:
1785  if (type->isAtomicType()) {
1786  EmitAtomicInit(const_cast<Expr*>(init), lvalue);
1787  } else {
1789  if (isa<VarDecl>(D))
1790  Overlap = AggValueSlot::DoesNotOverlap;
1791  else if (auto *FD = dyn_cast<FieldDecl>(D))
1792  Overlap = overlapForFieldInit(FD);
1793  // TODO: how can we delay here if D is captured by its initializer?
1794  EmitAggExpr(init, AggValueSlot::forLValue(lvalue,
1798  Overlap));
1799  }
1800  return;
1801  }
1802  llvm_unreachable("bad evaluation kind");
1803 }
1804 
1805 /// Enter a destroy cleanup for the given local variable.
1807  const CodeGenFunction::AutoVarEmission &emission,
1808  QualType::DestructionKind dtorKind) {
1809  assert(dtorKind != QualType::DK_none);
1810 
1811  // Note that for __block variables, we want to destroy the
1812  // original stack object, not the possibly forwarded object.
1813  Address addr = emission.getObjectAddress(*this);
1814 
1815  const VarDecl *var = emission.Variable;
1816  QualType type = var->getType();
1817 
1818  CleanupKind cleanupKind = NormalAndEHCleanup;
1819  CodeGenFunction::Destroyer *destroyer = nullptr;
1820 
1821  switch (dtorKind) {
1822  case QualType::DK_none:
1823  llvm_unreachable("no cleanup for trivially-destructible variable");
1824 
1826  // If there's an NRVO flag on the emission, we need a different
1827  // cleanup.
1828  if (emission.NRVOFlag) {
1829  assert(!type->isArrayType());
1831  EHStack.pushCleanup<DestroyNRVOVariableCXX>(cleanupKind, addr, dtor,
1832  emission.NRVOFlag);
1833  return;
1834  }
1835  break;
1836 
1838  // Suppress cleanups for pseudo-strong variables.
1839  if (var->isARCPseudoStrong()) return;
1840 
1841  // Otherwise, consider whether to use an EH cleanup or not.
1842  cleanupKind = getARCCleanupKind();
1843 
1844  // Use the imprecise destroyer by default.
1845  if (!var->hasAttr<ObjCPreciseLifetimeAttr>())
1847  break;
1848 
1850  break;
1851 
1854  if (emission.NRVOFlag) {
1855  assert(!type->isArrayType());
1856  EHStack.pushCleanup<DestroyNRVOVariableC>(cleanupKind, addr,
1857  emission.NRVOFlag, type);
1858  return;
1859  }
1860  break;
1861  }
1862 
1863  // If we haven't chosen a more specific destroyer, use the default.
1864  if (!destroyer) destroyer = getDestroyer(dtorKind);
1865 
1866  // Use an EH cleanup in array destructors iff the destructor itself
1867  // is being pushed as an EH cleanup.
1868  bool useEHCleanup = (cleanupKind & EHCleanup);
1869  EHStack.pushCleanup<DestroyObject>(cleanupKind, addr, type, destroyer,
1870  useEHCleanup);
1871 }
1872 
1874  assert(emission.Variable && "emission was not valid!");
1875 
1876  // If this was emitted as a global constant, we're done.
1877  if (emission.wasEmittedAsGlobal()) return;
1878 
1879  // If we don't have an insertion point, we're done. Sema prevents
1880  // us from jumping into any of these scopes anyway.
1881  if (!HaveInsertPoint()) return;
1882 
1883  const VarDecl &D = *emission.Variable;
1884 
1885  // Check the type for a cleanup.
1886  if (QualType::DestructionKind dtorKind = D.getType().isDestructedType())
1887  emitAutoVarTypeCleanup(emission, dtorKind);
1888 
1889  // In GC mode, honor objc_precise_lifetime.
1890  if (getLangOpts().getGC() != LangOptions::NonGC &&
1891  D.hasAttr<ObjCPreciseLifetimeAttr>()) {
1892  EHStack.pushCleanup<ExtendGCLifetime>(NormalCleanup, &D);
1893  }
1894 
1895  // Handle the cleanup attribute.
1896  if (const CleanupAttr *CA = D.getAttr<CleanupAttr>()) {
1897  const FunctionDecl *FD = CA->getFunctionDecl();
1898 
1899  llvm::Constant *F = CGM.GetAddrOfFunction(FD);
1900  assert(F && "Could not find function!");
1901 
1903  EHStack.pushCleanup<CallCleanupFunction>(NormalAndEHCleanup, F, &Info, &D);
1904  }
1905 
1906  // If this is a block variable, call _Block_object_destroy
1907  // (on the unforwarded address). Don't enter this cleanup if we're in pure-GC
1908  // mode.
1909  if (emission.IsEscapingByRef &&
1910  CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
1912  if (emission.Variable->getType().isObjCGCWeak())
1913  Flags |= BLOCK_FIELD_IS_WEAK;
1914  enterByrefCleanup(NormalAndEHCleanup, emission.Addr, Flags,
1915  /*LoadBlockVarAddr*/ false,
1916  cxxDestructorCanThrow(emission.Variable->getType()));
1917  }
1918 }
1919 
1922  switch (kind) {
1923  case QualType::DK_none: llvm_unreachable("no destroyer for trivial dtor");
1925  return destroyCXXObject;
1927  return destroyARCStrongPrecise;
1929  return destroyARCWeak;
1931  return destroyNonTrivialCStruct;
1932  }
1933  llvm_unreachable("Unknown DestructionKind");
1934 }
1935 
1936 /// pushEHDestroy - Push the standard destructor for the given type as
1937 /// an EH-only cleanup.
1939  Address addr, QualType type) {
1940  assert(dtorKind && "cannot push destructor for trivial type");
1941  assert(needsEHCleanup(dtorKind));
1942 
1943  pushDestroy(EHCleanup, addr, type, getDestroyer(dtorKind), true);
1944 }
1945 
1946 /// pushDestroy - Push the standard destructor for the given type as
1947 /// at least a normal cleanup.
1949  Address addr, QualType type) {
1950  assert(dtorKind && "cannot push destructor for trivial type");
1951 
1952  CleanupKind cleanupKind = getCleanupKind(dtorKind);
1953  pushDestroy(cleanupKind, addr, type, getDestroyer(dtorKind),
1954  cleanupKind & EHCleanup);
1955 }
1956 
1958  QualType type, Destroyer *destroyer,
1959  bool useEHCleanupForArray) {
1960  pushFullExprCleanup<DestroyObject>(cleanupKind, addr, type,
1961  destroyer, useEHCleanupForArray);
1962 }
1963 
1965  EHStack.pushCleanup<CallStackRestore>(Kind, SPMem);
1966 }
1967 
1969  CleanupKind cleanupKind, Address addr, QualType type,
1970  Destroyer *destroyer, bool useEHCleanupForArray) {
1971  // Push an EH-only cleanup for the object now.
1972  // FIXME: When popping normal cleanups, we need to keep this EH cleanup
1973  // around in case a temporary's destructor throws an exception.
1974  if (cleanupKind & EHCleanup)
1975  EHStack.pushCleanup<DestroyObject>(
1976  static_cast<CleanupKind>(cleanupKind & ~NormalCleanup), addr, type,
1977  destroyer, useEHCleanupForArray);
1978 
1979  // Remember that we need to push a full cleanup for the object at the
1980  // end of the full-expression.
1981  pushCleanupAfterFullExpr<DestroyObject>(
1982  cleanupKind, addr, type, destroyer, useEHCleanupForArray);
1983 }
1984 
1985 /// emitDestroy - Immediately perform the destruction of the given
1986 /// object.
1987 ///
1988 /// \param addr - the address of the object; a type*
1989 /// \param type - the type of the object; if an array type, all
1990 /// objects are destroyed in reverse order
1991 /// \param destroyer - the function to call to destroy individual
1992 /// elements
1993 /// \param useEHCleanupForArray - whether an EH cleanup should be
1994 /// used when destroying array elements, in case one of the
1995 /// destructions throws an exception
1997  Destroyer *destroyer,
1998  bool useEHCleanupForArray) {
1999  const ArrayType *arrayType = getContext().getAsArrayType(type);
2000  if (!arrayType)
2001  return destroyer(*this, addr, type);
2002 
2003  llvm::Value *length = emitArrayLength(arrayType, type, addr);
2004 
2005  CharUnits elementAlign =
2006  addr.getAlignment()
2007  .alignmentOfArrayElement(getContext().getTypeSizeInChars(type));
2008 
2009  // Normally we have to check whether the array is zero-length.
2010  bool checkZeroLength = true;
2011 
2012  // But if the array length is constant, we can suppress that.
2013  if (llvm::ConstantInt *constLength = dyn_cast<llvm::ConstantInt>(length)) {
2014  // ...and if it's constant zero, we can just skip the entire thing.
2015  if (constLength->isZero()) return;
2016  checkZeroLength = false;
2017  }
2018 
2019  llvm::Value *begin = addr.getPointer();
2020  llvm::Value *end = Builder.CreateInBoundsGEP(begin, length);
2021  emitArrayDestroy(begin, end, type, elementAlign, destroyer,
2022  checkZeroLength, useEHCleanupForArray);
2023 }
2024 
2025 /// emitArrayDestroy - Destroys all the elements of the given array,
2026 /// beginning from last to first. The array cannot be zero-length.
2027 ///
2028 /// \param begin - a type* denoting the first element of the array
2029 /// \param end - a type* denoting one past the end of the array
2030 /// \param elementType - the element type of the array
2031 /// \param destroyer - the function to call to destroy elements
2032 /// \param useEHCleanup - whether to push an EH cleanup to destroy
2033 /// the remaining elements in case the destruction of a single
2034 /// element throws
2036  llvm::Value *end,
2037  QualType elementType,
2038  CharUnits elementAlign,
2039  Destroyer *destroyer,
2040  bool checkZeroLength,
2041  bool useEHCleanup) {
2042  assert(!elementType->isArrayType());
2043 
2044  // The basic structure here is a do-while loop, because we don't
2045  // need to check for the zero-element case.
2046  llvm::BasicBlock *bodyBB = createBasicBlock("arraydestroy.body");
2047  llvm::BasicBlock *doneBB = createBasicBlock("arraydestroy.done");
2048 
2049  if (checkZeroLength) {
2050  llvm::Value *isEmpty = Builder.CreateICmpEQ(begin, end,
2051  "arraydestroy.isempty");
2052  Builder.CreateCondBr(isEmpty, doneBB, bodyBB);
2053  }
2054 
2055  // Enter the loop body, making that address the current address.
2056  llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
2057  EmitBlock(bodyBB);
2058  llvm::PHINode *elementPast =
2059  Builder.CreatePHI(begin->getType(), 2, "arraydestroy.elementPast");
2060  elementPast->addIncoming(end, entryBB);
2061 
2062  // Shift the address back by one element.
2063  llvm::Value *negativeOne = llvm::ConstantInt::get(SizeTy, -1, true);
2064  llvm::Value *element = Builder.CreateInBoundsGEP(elementPast, negativeOne,
2065  "arraydestroy.element");
2066 
2067  if (useEHCleanup)
2068  pushRegularPartialArrayCleanup(begin, element, elementType, elementAlign,
2069  destroyer);
2070 
2071  // Perform the actual destruction there.
2072  destroyer(*this, Address(element, elementAlign), elementType);
2073 
2074  if (useEHCleanup)
2075  PopCleanupBlock();
2076 
2077  // Check whether we've reached the end.
2078  llvm::Value *done = Builder.CreateICmpEQ(element, begin, "arraydestroy.done");
2079  Builder.CreateCondBr(done, doneBB, bodyBB);
2080  elementPast->addIncoming(element, Builder.GetInsertBlock());
2081 
2082  // Done.
2083  EmitBlock(doneBB);
2084 }
2085 
2086 /// Perform partial array destruction as if in an EH cleanup. Unlike
2087 /// emitArrayDestroy, the element type here may still be an array type.
2089  llvm::Value *begin, llvm::Value *end,
2090  QualType type, CharUnits elementAlign,
2091  CodeGenFunction::Destroyer *destroyer) {
2092  // If the element type is itself an array, drill down.
2093  unsigned arrayDepth = 0;
2094  while (const ArrayType *arrayType = CGF.getContext().getAsArrayType(type)) {
2095  // VLAs don't require a GEP index to walk into.
2096  if (!isa<VariableArrayType>(arrayType))
2097  arrayDepth++;
2098  type = arrayType->getElementType();
2099  }
2100 
2101  if (arrayDepth) {
2102  llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
2103 
2104  SmallVector<llvm::Value*,4> gepIndices(arrayDepth+1, zero);
2105  begin = CGF.Builder.CreateInBoundsGEP(begin, gepIndices, "pad.arraybegin");
2106  end = CGF.Builder.CreateInBoundsGEP(end, gepIndices, "pad.arrayend");
2107  }
2108 
2109  // Destroy the array. We don't ever need an EH cleanup because we
2110  // assume that we're in an EH cleanup ourselves, so a throwing
2111  // destructor causes an immediate terminate.
2112  CGF.emitArrayDestroy(begin, end, type, elementAlign, destroyer,
2113  /*checkZeroLength*/ true, /*useEHCleanup*/ false);
2114 }
2115 
2116 namespace {
2117  /// RegularPartialArrayDestroy - a cleanup which performs a partial
2118  /// array destroy where the end pointer is regularly determined and
2119  /// does not need to be loaded from a local.
2120  class RegularPartialArrayDestroy final : public EHScopeStack::Cleanup {
2121  llvm::Value *ArrayBegin;
2122  llvm::Value *ArrayEnd;
2123  QualType ElementType;
2125  CharUnits ElementAlign;
2126  public:
2127  RegularPartialArrayDestroy(llvm::Value *arrayBegin, llvm::Value *arrayEnd,
2128  QualType elementType, CharUnits elementAlign,
2129  CodeGenFunction::Destroyer *destroyer)
2130  : ArrayBegin(arrayBegin), ArrayEnd(arrayEnd),
2131  ElementType(elementType), Destroyer(destroyer),
2132  ElementAlign(elementAlign) {}
2133 
2134  void Emit(CodeGenFunction &CGF, Flags flags) override {
2135  emitPartialArrayDestroy(CGF, ArrayBegin, ArrayEnd,
2136  ElementType, ElementAlign, Destroyer);
2137  }
2138  };
2139 
2140  /// IrregularPartialArrayDestroy - a cleanup which performs a
2141  /// partial array destroy where the end pointer is irregularly
2142  /// determined and must be loaded from a local.
2143  class IrregularPartialArrayDestroy final : public EHScopeStack::Cleanup {
2144  llvm::Value *ArrayBegin;
2145  Address ArrayEndPointer;
2146  QualType ElementType;
2148  CharUnits ElementAlign;
2149  public:
2150  IrregularPartialArrayDestroy(llvm::Value *arrayBegin,
2151  Address arrayEndPointer,
2152  QualType elementType,
2153  CharUnits elementAlign,
2154  CodeGenFunction::Destroyer *destroyer)
2155  : ArrayBegin(arrayBegin), ArrayEndPointer(arrayEndPointer),
2156  ElementType(elementType), Destroyer(destroyer),
2157  ElementAlign(elementAlign) {}
2158 
2159  void Emit(CodeGenFunction &CGF, Flags flags) override {
2160  llvm::Value *arrayEnd = CGF.Builder.CreateLoad(ArrayEndPointer);
2161  emitPartialArrayDestroy(CGF, ArrayBegin, arrayEnd,
2162  ElementType, ElementAlign, Destroyer);
2163  }
2164  };
2165 } // end anonymous namespace
2166 
2167 /// pushIrregularPartialArrayCleanup - Push an EH cleanup to destroy
2168 /// already-constructed elements of the given array. The cleanup
2169 /// may be popped with DeactivateCleanupBlock or PopCleanupBlock.
2170 ///
2171 /// \param elementType - the immediate element type of the array;
2172 /// possibly still an array type
2174  Address arrayEndPointer,
2175  QualType elementType,
2176  CharUnits elementAlign,
2177  Destroyer *destroyer) {
2178  pushFullExprCleanup<IrregularPartialArrayDestroy>(EHCleanup,
2179  arrayBegin, arrayEndPointer,
2180  elementType, elementAlign,
2181  destroyer);
2182 }
2183 
2184 /// pushRegularPartialArrayCleanup - Push an EH cleanup to destroy
2185 /// already-constructed elements of the given array. The cleanup
2186 /// may be popped with DeactivateCleanupBlock or PopCleanupBlock.
2187 ///
2188 /// \param elementType - the immediate element type of the array;
2189 /// possibly still an array type
2191  llvm::Value *arrayEnd,
2192  QualType elementType,
2193  CharUnits elementAlign,
2194  Destroyer *destroyer) {
2195  pushFullExprCleanup<RegularPartialArrayDestroy>(EHCleanup,
2196  arrayBegin, arrayEnd,
2197  elementType, elementAlign,
2198  destroyer);
2199 }
2200 
2201 /// Lazily declare the @llvm.lifetime.start intrinsic.
2203  if (LifetimeStartFn)
2204  return LifetimeStartFn;
2205  LifetimeStartFn = llvm::Intrinsic::getDeclaration(&getModule(),
2206  llvm::Intrinsic::lifetime_start, AllocaInt8PtrTy);
2207  return LifetimeStartFn;
2208 }
2209 
2210 /// Lazily declare the @llvm.lifetime.end intrinsic.
2212  if (LifetimeEndFn)
2213  return LifetimeEndFn;
2214  LifetimeEndFn = llvm::Intrinsic::getDeclaration(&getModule(),
2215  llvm::Intrinsic::lifetime_end, AllocaInt8PtrTy);
2216  return LifetimeEndFn;
2217 }
2218 
2219 namespace {
2220  /// A cleanup to perform a release of an object at the end of a
2221  /// function. This is used to balance out the incoming +1 of a
2222  /// ns_consumed argument when we can't reasonably do that just by
2223  /// not doing the initial retain for a __block argument.
2224  struct ConsumeARCParameter final : EHScopeStack::Cleanup {
2225  ConsumeARCParameter(llvm::Value *param,
2226  ARCPreciseLifetime_t precise)
2227  : Param(param), Precise(precise) {}
2228 
2229  llvm::Value *Param;
2230  ARCPreciseLifetime_t Precise;
2231 
2232  void Emit(CodeGenFunction &CGF, Flags flags) override {
2233  CGF.EmitARCRelease(Param, Precise);
2234  }
2235  };
2236 } // end anonymous namespace
2237 
2238 /// Emit an alloca (or GlobalValue depending on target)
2239 /// for the specified parameter and set up LocalDeclMap.
2241  unsigned ArgNo) {
2242  // FIXME: Why isn't ImplicitParamDecl a ParmVarDecl?
2243  assert((isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D)) &&
2244  "Invalid argument to EmitParmDecl");
2245 
2246  Arg.getAnyValue()->setName(D.getName());
2247 
2248  QualType Ty = D.getType();
2249 
2250  // Use better IR generation for certain implicit parameters.
2251  if (auto IPD = dyn_cast<ImplicitParamDecl>(&D)) {
2252  // The only implicit argument a block has is its literal.
2253  // This may be passed as an inalloca'ed value on Windows x86.
2254  if (BlockInfo) {
2255  llvm::Value *V = Arg.isIndirect()
2257  : Arg.getDirectValue();
2258  setBlockContextParameter(IPD, ArgNo, V);
2259  return;
2260  }
2261  }
2262 
2263  Address DeclPtr = Address::invalid();
2264  bool DoStore = false;
2265  bool IsScalar = hasScalarEvaluationKind(Ty);
2266  // If we already have a pointer to the argument, reuse the input pointer.
2267  if (Arg.isIndirect()) {
2268  DeclPtr = Arg.getIndirectAddress();
2269  // If we have a prettier pointer type at this point, bitcast to that.
2270  unsigned AS = DeclPtr.getType()->getAddressSpace();
2271  llvm::Type *IRTy = ConvertTypeForMem(Ty)->getPointerTo(AS);
2272  if (DeclPtr.getType() != IRTy)
2273  DeclPtr = Builder.CreateBitCast(DeclPtr, IRTy, D.getName());
2274  // Indirect argument is in alloca address space, which may be different
2275  // from the default address space.
2276  auto AllocaAS = CGM.getASTAllocaAddressSpace();
2277  auto *V = DeclPtr.getPointer();
2278  auto SrcLangAS = getLangOpts().OpenCL ? LangAS::opencl_private : AllocaAS;
2279  auto DestLangAS =
2281  if (SrcLangAS != DestLangAS) {
2282  assert(getContext().getTargetAddressSpace(SrcLangAS) ==
2283  CGM.getDataLayout().getAllocaAddrSpace());
2284  auto DestAS = getContext().getTargetAddressSpace(DestLangAS);
2285  auto *T = V->getType()->getPointerElementType()->getPointerTo(DestAS);
2286  DeclPtr = Address(getTargetHooks().performAddrSpaceCast(
2287  *this, V, SrcLangAS, DestLangAS, T, true),
2288  DeclPtr.getAlignment());
2289  }
2290 
2291  // Push a destructor cleanup for this parameter if the ABI requires it.
2292  // Don't push a cleanup in a thunk for a method that will also emit a
2293  // cleanup.
2295  Ty->getAs<RecordType>()->getDecl()->isParamDestroyedInCallee()) {
2296  if (QualType::DestructionKind DtorKind = Ty.isDestructedType()) {
2297  assert((DtorKind == QualType::DK_cxx_destructor ||
2298  DtorKind == QualType::DK_nontrivial_c_struct) &&
2299  "unexpected destructor type");
2300  pushDestroy(DtorKind, DeclPtr, Ty);
2301  CalleeDestructedParamCleanups[cast<ParmVarDecl>(&D)] =
2303  }
2304  }
2305  } else {
2306  // Check if the parameter address is controlled by OpenMP runtime.
2307  Address OpenMPLocalAddr =
2308  getLangOpts().OpenMP
2309  ? CGM.getOpenMPRuntime().getAddressOfLocalVariable(*this, &D)
2310  : Address::invalid();
2311  if (getLangOpts().OpenMP && OpenMPLocalAddr.isValid()) {
2312  DeclPtr = OpenMPLocalAddr;
2313  } else {
2314  // Otherwise, create a temporary to hold the value.
2315  DeclPtr = CreateMemTemp(Ty, getContext().getDeclAlign(&D),
2316  D.getName() + ".addr");
2317  }
2318  DoStore = true;
2319  }
2320 
2321  llvm::Value *ArgVal = (DoStore ? Arg.getDirectValue() : nullptr);
2322 
2323  LValue lv = MakeAddrLValue(DeclPtr, Ty);
2324  if (IsScalar) {
2325  Qualifiers qs = Ty.getQualifiers();
2326  if (Qualifiers::ObjCLifetime lt = qs.getObjCLifetime()) {
2327  // We honor __attribute__((ns_consumed)) for types with lifetime.
2328  // For __strong, it's handled by just skipping the initial retain;
2329  // otherwise we have to balance out the initial +1 with an extra
2330  // cleanup to do the release at the end of the function.
2331  bool isConsumed = D.hasAttr<NSConsumedAttr>();
2332 
2333  // If a parameter is pseudo-strong then we can omit the implicit retain.
2334  if (D.isARCPseudoStrong()) {
2335  assert(lt == Qualifiers::OCL_Strong &&
2336  "pseudo-strong variable isn't strong?");
2337  assert(qs.hasConst() && "pseudo-strong variable should be const!");
2339  }
2340 
2341  // Load objects passed indirectly.
2342  if (Arg.isIndirect() && !ArgVal)
2343  ArgVal = Builder.CreateLoad(DeclPtr);
2344 
2345  if (lt == Qualifiers::OCL_Strong) {
2346  if (!isConsumed) {
2347  if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
2348  // use objc_storeStrong(&dest, value) for retaining the
2349  // object. But first, store a null into 'dest' because
2350  // objc_storeStrong attempts to release its old value.
2351  llvm::Value *Null = CGM.EmitNullConstant(D.getType());
2352  EmitStoreOfScalar(Null, lv, /* isInitialization */ true);
2353  EmitARCStoreStrongCall(lv.getAddress(), ArgVal, true);
2354  DoStore = false;
2355  }
2356  else
2357  // Don't use objc_retainBlock for block pointers, because we
2358  // don't want to Block_copy something just because we got it
2359  // as a parameter.
2360  ArgVal = EmitARCRetainNonBlock(ArgVal);
2361  }
2362  } else {
2363  // Push the cleanup for a consumed parameter.
2364  if (isConsumed) {
2365  ARCPreciseLifetime_t precise = (D.hasAttr<ObjCPreciseLifetimeAttr>()
2367  EHStack.pushCleanup<ConsumeARCParameter>(getARCCleanupKind(), ArgVal,
2368  precise);
2369  }
2370 
2371  if (lt == Qualifiers::OCL_Weak) {
2372  EmitARCInitWeak(DeclPtr, ArgVal);
2373  DoStore = false; // The weak init is a store, no need to do two.
2374  }
2375  }
2376 
2377  // Enter the cleanup scope.
2378  EmitAutoVarWithLifetime(*this, D, DeclPtr, lt);
2379  }
2380  }
2381 
2382  // Store the initial value into the alloca.
2383  if (DoStore)
2384  EmitStoreOfScalar(ArgVal, lv, /* isInitialization */ true);
2385 
2386  setAddrOfLocalVar(&D, DeclPtr);
2387 
2388  // Emit debug info for param declaration.
2389  if (CGDebugInfo *DI = getDebugInfo()) {
2390  if (CGM.getCodeGenOpts().getDebugInfo() >=
2392  DI->EmitDeclareOfArgVariable(&D, DeclPtr.getPointer(), ArgNo, Builder);
2393  }
2394  }
2395 
2396  if (D.hasAttr<AnnotateAttr>())
2397  EmitVarAnnotations(&D, DeclPtr.getPointer());
2398 
2399  // We can only check return value nullability if all arguments to the
2400  // function satisfy their nullability preconditions. This makes it necessary
2401  // to emit null checks for args in the function body itself.
2402  if (requiresReturnValueNullabilityCheck()) {
2403  auto Nullability = Ty->getNullability(getContext());
2405  SanitizerScope SanScope(this);
2406  RetValNullabilityPrecondition =
2407  Builder.CreateAnd(RetValNullabilityPrecondition,
2408  Builder.CreateIsNotNull(Arg.getAnyValue()));
2409  }
2410  }
2411 }
2412 
2414  CodeGenFunction *CGF) {
2415  if (!LangOpts.OpenMP || (!LangOpts.EmitAllDecls && !D->isUsed()))
2416  return;
2417  getOpenMPRuntime().emitUserDefinedReduction(CGF, D);
2418 }
2419 
2421  getOpenMPRuntime().checkArchForUnifiedAddressing(*this, D);
2422 }
const llvm::DataLayout & getDataLayout() const
CGOpenCLRuntime & getOpenCLRuntime()
Return a reference to the configured OpenCL runtime.
ReturnValueSlot - Contains the address where the return value of a function can be stored...
Definition: CGCall.h:361
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Defines the clang::ASTContext interface.
static bool canEmitInitWithFewStoresAfterBZero(llvm::Constant *Init, unsigned &NumStores)
Decide whether we can emit the non-zero parts of the specified initializer with equal or fewer than N...
Definition: CGDecl.cpp:859
void setImplicit(bool I=true)
Definition: DeclBase.h:548
Represents a function declaration or definition.
Definition: Decl.h:1738
llvm::IntegerType * IntTy
int
void EmitStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)
Definition: CGDecl.cpp:378
llvm::Value * EmitARCRetainAutoreleaseScalarExpr(const Expr *expr)
Definition: CGObjC.cpp:3173
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
Definition: CGDecl.cpp:1921
A (possibly-)qualified type.
Definition: Type.h:638
Allows to disable automatic handling of functions used in target regions as those marked as omp decla...
void EmitExtendGCLifetime(llvm::Value *object)
EmitExtendGCLifetime - Given a pointer to an Objective-C object, make sure it survives garbage collec...
Definition: CGObjC.cpp:3383
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2101
bool isArrayType() const
Definition: Type.h:6345
llvm::Type * ConvertTypeForMem(QualType T)
const CodeGenOptions & getCodeGenOpts() const
void EmitVarDecl(const VarDecl &D)
EmitVarDecl - Emit a local variable declaration.
Definition: CGDecl.cpp:158
Address CreateMemTemp(QualType T, const Twine &Name="tmp", Address *Alloca=nullptr)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...
Definition: CGExpr.cpp:139
llvm::Constant * EmitCheckTypeDescriptor(QualType T)
Emit a description of a type in a format suitable for passing to a runtime sanitizer handler...
Definition: CGExpr.cpp:2710
void enterFullExpression(const FullExpr *E)
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
llvm::LLVMContext & getLLVMContext()
Stmt - This represents one statement.
Definition: Stmt.h:66
llvm::Constant * tryEmitForInitializer(const VarDecl &D)
Try to emit the initiaizer of the given declaration as an abstract constant.
Defines the SourceManager interface.
bool isRecordType() const
Definition: Type.h:6369
bool hasLabelBeenSeenInCurrentScope() const
Return true if a label was seen in the current scope.
void emitAutoVarTypeCleanup(const AutoVarEmission &emission, QualType::DestructionKind dtorKind)
Enter a destroy cleanup for the given local variable.
Definition: CGDecl.cpp:1806
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
void EmitCheck(ArrayRef< std::pair< llvm::Value *, SanitizerMask >> Checked, SanitizerHandler Check, ArrayRef< llvm::Constant *> StaticArgs, ArrayRef< llvm::Value *> DynamicArgs)
Create a basic block that will call a handler function in a sanitizer runtime with the provided argum...
Definition: CGExpr.cpp:2927
void EmitAutoVarDecl(const VarDecl &D)
EmitAutoVarDecl - Emit an auto variable declaration.
Definition: CGDecl.cpp:1200
static Destroyer destroyARCStrongPrecise
void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
Definition: CGDecl.cpp:1968
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...
Definition: CGExpr.cpp:1914
static void emitStoresForInitAfterBZero(CodeGenModule &CGM, llvm::Constant *Init, Address Loc, bool isVolatile, CGBuilderTy &Builder)
For inits that canEmitInitWithFewStoresAfterBZero returned true for, emit the scalar stores that woul...
Definition: CGDecl.cpp:897
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2812
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1262
bool isZero() const
isZero - Test whether the quantity equals zero.
Definition: CharUnits.h:116
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
Definition: EHScopeStack.h:379
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:690
void EmitARCCopyWeak(Address dst, Address src)
void @objc_copyWeak(i8** dest, i8** src) Disregards the current value in dest.
Definition: CGObjC.cpp:2402
constexpr XRayInstrMask Function
Definition: XRayInstr.h:39
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
Retain the given object, with normal retain semantics.
Definition: CGObjC.cpp:2065
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2484
const DeclContext * getParentFunctionOrMethod() const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext...
Definition: DeclBase.cpp:254
The type is a struct containing a field whose type is not PCK_Trivial.
Definition: Type.h:1088
static bool shouldUseBZeroPlusStoresToInitialize(llvm::Constant *Init, uint64_t GlobalSize)
Decide whether we should use bzero plus some stores to initialize a local variable instead of using a...
Definition: CGDecl.cpp:943
static llvm::Value * shouldUseMemSetToInitialize(llvm::Constant *Init, uint64_t GlobalSize)
Decide whether we should use memset to initialize a local variable instead of using a memcpy from a c...
Definition: CGDecl.cpp:964
RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::Instruction **callOrInvoke, SourceLocation Loc)
EmitCall - Generate a call of the given function, expecting the given result type, and using the given argument list which specifies both the LLVM arguments and the types they were derived from.
Definition: CGCall.cpp:3807
Represents a variable declaration or definition.
Definition: Decl.h:813
Address getObjectAddress(CodeGenFunction &CGF) const
Returns the address of the object within this declaration.
RAII object to set/unset CodeGenFunction::IsSanitizerScope.
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6748
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:26
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
Definition: CGDebugInfo.h:54
void EmitVariablyModifiedType(QualType Ty)
EmitVLASize - Capture all the sizes for the VLA expressions in the given variably-modified type and s...
llvm::Value * getPointer() const
Definition: Address.h:38
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:24
unsigned getAddressSpace() const
Return the address space that this address resides in.
Definition: Address.h:57
The collection of all-type qualifiers we support.
Definition: Type.h:141
void add(RValue rvalue, QualType type)
Definition: CGCall.h:285
bool isARCPseudoStrong() const
Determine whether this variable is an ARC pseudo-__strong variable.
Definition: Decl.h:1360
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:348
const TargetInfo & getTarget() const
One of these records is kept for each identifier that is lexed.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:1018
void emitDestroy(Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
emitDestroy - Immediately perform the destruction of the given object.
Definition: CGDecl.cpp:1996
void emitByrefStructureInit(const AutoVarEmission &emission)
Initialize the structural components of a __block variable, i.e.
Definition: CGBlocks.cpp:2827
VlaSizePair getVLAElements1D(const VariableArrayType *vla)
Return the number of elements for a single dimension for the given array type.
Address getAddress() const
Definition: CGValue.h:327
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
llvm::Constant * tryEmitAbstractForInitializer(const VarDecl &D)
Try to emit the initializer of the given declaration as an abstract constant.
void EmitExprAsInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
EmitExprAsInit - Emits the code necessary to initialize a location in memory with the given initializ...
Definition: CGDecl.cpp:1762
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
Definition: CGExpr.cpp:593
FullExpr - Represents a "full-expression" node.
Definition: Expr.h:877
Qualifiers::ObjCLifetime getObjCLifetime() const
Definition: CGValue.h:266
bool isReferenceType() const
Definition: Type.h:6308
void pushEHDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
pushEHDestroy - Push the standard destructor for the given type as an EH-only cleanup.
Definition: CGDecl.cpp:1938
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Definition: EHScopeStack.h:81
static bool containsUndef(llvm::Constant *constant)
Definition: CGDecl.cpp:1162
void reportGlobalToASan(llvm::GlobalVariable *GV, const VarDecl &D, bool IsDynInit=false)
Address getAllocatedAddress() const
Returns the raw, allocated address, which is not necessarily the address of the object itself...
CleanupKind getCleanupKind(QualType::DestructionKind kind)
IdentifierTable & Idents
Definition: ASTContext.h:566
void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource Source=AlignmentSource::Type, bool isInit=false, bool isNontemporal=false)
EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...
void setNonGC(bool Value)
Definition: CGValue.h:277
llvm::Constant * getLLVMLifetimeStartFn()
Lazily declare the .lifetime.start intrinsic.
Definition: CGDecl.cpp:2202
llvm::Value * EmitARCStoreStrongCall(Address addr, llvm::Value *value, bool resultIgnored)
Store into a strong object.
Definition: CGObjC.cpp:2217
void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin, llvm::Value *arrayEnd, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)
pushRegularPartialArrayCleanup - Push an EH cleanup to destroy already-constructed elements of the gi...
Definition: CGDecl.cpp:2190
static bool hasScalarEvaluationKind(QualType T)
static void drillIntoBlockVariable(CodeGenFunction &CGF, LValue &lvalue, const VarDecl *var)
Definition: CGDecl.cpp:713
Base object ctor.
Definition: ABI.h:27
void defaultInitNonTrivialCStructVar(LValue Dst)
Address CreateElementBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Cast the element type of the given address to a different type, preserving information like the align...
Definition: CGBuilder.h:157
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
void EmitOMPRequiresDecl(const OMPRequiresDecl *D)
Emit a code for requires directive.
Definition: CGDecl.cpp:2420
void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D, CodeGenFunction *CGF=nullptr)
Emit a code for declare reduction construct.
Definition: CGDecl.cpp:2413
bool isOne() const
isOne - Test whether the quantity equals one.
Definition: CharUnits.h:119
An x-value expression is a reference to an object with independent storage but which can be "moved"...
Definition: Specifiers.h:119
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:405
void EmitGlobalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl)
Emit information about a global variable.
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:67
void setStaticLocalDeclAddress(const VarDecl *D, llvm::Constant *C)
child_range children()
Definition: Stmt.cpp:237
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6142
static void emitStoresForConstant(CodeGenModule &CGM, const VarDecl &D, Address Loc, bool isVolatile, CGBuilderTy &Builder, llvm::Constant *constant)
Definition: CGDecl.cpp:1094
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind...
const_arg_iterator arg_begin() const
llvm::Value * EmitARCUnsafeUnretainedScalarExpr(const Expr *expr)
EmitARCUnsafeUnretainedScalarExpr - Semantically equivalent to immediately releasing the resut of Emi...
Definition: CGObjC.cpp:3284
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:274
static llvm::Constant * patternFor(CodeGenModule &CGM, llvm::Type *Ty)
Definition: CGDecl.cpp:972
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1382
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
Expr * IgnoreParenCasts() LLVM_READONLY
IgnoreParenCasts - Ignore parentheses and casts.
Definition: Expr.cpp:2595
Values of this type can never be null.
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:41
static void emitStoresForPatternInit(CodeGenModule &CGM, const VarDecl &D, Address Loc, bool isVolatile, CGBuilderTy &Builder)
Definition: CGDecl.cpp:1153
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
llvm::Value * EmitARCRetainScalarExpr(const Expr *expr)
EmitARCRetainScalarExpr - Semantically equivalent to EmitARCRetainObject(e->getType(), EmitScalarExpr(e)), but making a best-effort attempt to peephole expressions that naturally produce retained objects.
Definition: CGObjC.cpp:3157
Denotes a cleanup that should run when a scope is exited using normal control flow (falling off the e...
Definition: EHScopeStack.h:85
void EmitAtomicInit(Expr *E, LValue lvalue)
Definition: CGAtomic.cpp:2004
const internal::VariadicDynCastAllOfMatcher< Stmt, CastExpr > castExpr
Matches any cast nodes of Clang&#39;s AST.
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1478
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1918
static bool ContainsLabel(const Stmt *S, bool IgnoreCaseStmts=false)
ContainsLabel - Return true if the statement contains a label in it.
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1697
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
Definition: CGExpr.cpp:106
bool hasConst() const
Definition: Type.h:258
static bool isCapturedBy(const VarDecl &, const Expr *)
Determines whether the given __block variable is potentially captured by the given expression...
Definition: CGDecl.cpp:1515
void registerVLASizeExpression(QualType Ty, llvm::Metadata *SizeExpr)
Register VLA size expression debug node with the qualified type.
Definition: CGDebugInfo.h:348
This object can be modified without requiring retains or releases.
Definition: Type.h:162
bool isTypeConstant(QualType QTy, bool ExcludeCtorDtor)
isTypeConstant - Determine whether an object of this type can be emitted as a constant.
StorageDuration getStorageDuration() const
Get the storage duration of this variable, per C++ [basic.stc].
Definition: Decl.h:1081
llvm::Value * EmitLoadOfScalar(Address Addr, bool Volatile, QualType Ty, SourceLocation Loc, AlignmentSource Source=AlignmentSource::Type, bool isNontemporal=false)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
bool hasAttr() const
Definition: DeclBase.h:531
bool isValid() const
Definition: Address.h:36
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1241
std::pair< llvm::Value *, llvm::Value * > ComplexPairTy
AutoVarEmission EmitAutoVarAlloca(const VarDecl &var)
EmitAutoVarAlloca - Emit the alloca and debug information for a local variable.
Definition: CGDecl.cpp:1298
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1613
const CodeGen::CGBlockInfo * BlockInfo
IdentifierInfo & getOwn(StringRef Name)
Gets an IdentifierInfo for the given name without consulting external sources.
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:39
void setAddress(Address address)
Definition: CGValue.h:328
CleanupKind getARCCleanupKind()
Retrieves the default cleanup kind for an ARC cleanup.
StringRef getBlockMangledName(GlobalDecl GD, const BlockDecl *BD)
llvm::Constant * getNullPointer(llvm::PointerType *T, QualType QT)
Get target specific null pointer.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
AggValueSlot::Overlap_t overlapForFieldInit(const FieldDecl *FD)
Determine whether a field initialization may overlap some other object.
Address CreateDefaultAlignTempAlloca(llvm::Type *Ty, const Twine &Name="tmp")
CreateDefaultAlignedTempAlloca - This creates an alloca with the default ABI alignment of the given L...
Definition: CGExpr.cpp:119
This represents &#39;#pragma omp requires...&#39; directive.
Definition: DeclOpenMP.h:250
llvm::Value * EmitARCStoreWeak(Address addr, llvm::Value *value, bool ignored)
i8* @objc_storeWeak(i8** addr, i8* value) Returns value.
Definition: CGObjC.cpp:2347
void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit)
Emit code in this function to perform a guarded variable initialization.
Definition: CGDeclCXX.cpp:273
llvm::DILocalVariable * EmitDeclareOfAutoVariable(const VarDecl *Decl, llvm::Value *AI, CGBuilderTy &Builder)
Emit call to llvm.dbg.declare for an automatic variable declaration.
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
Pepresents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3858
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:637
This represents one expression.
Definition: Expr.h:106
SourceLocation End
void EmitARCMoveWeak(Address dst, Address src)
void @objc_moveWeak(i8** dest, i8** src) Disregards the current value in dest.
Definition: CGObjC.cpp:2393
Emit only debug info necessary for generating line number tables (-gline-tables-only).
Address getOriginalAllocatedAddress() const
Returns the address for the original alloca instruction.
void EmitAutoVarInit(const AutoVarEmission &emission)
Definition: CGDecl.cpp:1578
static Address invalid()
Definition: Address.h:35
std::string Label
void AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV)
Add global annotations that are set on D, for the global GV.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
Definition: Decl.h:1036
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
static CGCallee forDirect(llvm::Constant *functionPtr, const CGCalleeInfo &abstractInfo=CGCalleeInfo())
Definition: CGCall.h:134
virtual void EmitWorkGroupLocalVarDecl(CodeGenFunction &CGF, const VarDecl &D)
Emit the IR required for a work-group-local variable declaration, and add an entry to CGF&#39;s LocalDecl...
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5177
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2706
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
bool isExceptionVariable() const
Determine whether this variable is the exception variable in a C++ catch statememt or an Objective-C ...
Definition: Decl.h:1307
VlaSizePair getVLASize(const VariableArrayType *vla)
Returns an LLVM value that corresponds to the size, in non-variably-sized elements, of a variable length array type, plus that largest non-variably-sized element type.
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:44
ObjCLifetime getObjCLifetime() const
Definition: Type.h:326
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
DeclContext * getDeclContext()
Definition: DeclBase.h:427
SourceLocation Begin
static SVal getValue(SVal val, SValBuilder &svalBuilder)
const AstTypeMatcher< ArrayType > arrayType
Matches all kinds of arrays.
Base object dtor.
Definition: ABI.h:37
QualType getType() const
Definition: Expr.h:128
void EmitNullabilityCheck(LValue LHS, llvm::Value *RHS, SourceLocation Loc)
Given an assignment *LHS = RHS, emit a test that checks if RHS is nonnull, if LHS is marked _Nonnull...
Definition: CGDecl.cpp:719
llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD, bool IsConstant)
Returns LLVM linkage for a declarator.
Checking the value assigned to a _Nonnull pointer. Must not be null.
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
Definition: CharUnits.h:197
llvm::PointerType * AllocaInt8PtrTy
llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:296
void emitArrayDestroy(llvm::Value *begin, llvm::Value *end, QualType elementType, CharUnits elementAlign, Destroyer *destroyer, bool checkZeroLength, bool useEHCleanup)
emitArrayDestroy - Destroys all the elements of the given array, beginning from last to first...
Definition: CGDecl.cpp:2035
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6688
static bool hasNontrivialDestruction(QualType T)
hasNontrivialDestruction - Determine whether a type&#39;s destruction is non-trivial. ...
Definition: CGDecl.cpp:304
float __ovld __cnfn length(float p)
Return the length of vector p, i.e., sqrt(p.x2 + p.y 2 + ...)
const LangOptions & getLangOpts() const
ASTContext & getContext() const
GlobalDecl - represents a global declaration.
Definition: GlobalDecl.h:35
The l-value was considered opaque, so the alignment was determined from a type.
void setBlockContextParameter(const ImplicitParamDecl *D, unsigned argNum, llvm::Value *ptr)
Definition: CGBlocks.cpp:1484
llvm::Constant * getOrCreateStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)
Definition: CGDecl.cpp:211
There is no lifetime qualification on this type.
Definition: Type.h:158
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:142
Assigning into this object requires the old value to be released and the new value to be retained...
Definition: Type.h:169
llvm::GlobalVariable * AddInitializerToStaticVarDecl(const VarDecl &D, llvm::GlobalVariable *GV)
AddInitializerToStaticVarDecl - Add the initializer for &#39;D&#39; to the global variable that has already b...
Definition: CGDecl.cpp:314
Kind
void pushDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
pushDestroy - Push the standard destructor for the given type as at least a normal cleanup...
Definition: CGDecl.cpp:1948
Encodes a location in the source.
void EmitAndRegisterVariableArrayDimensions(CGDebugInfo *DI, const VarDecl &D, bool EmitDebugInfo)
Emits the alloca and debug information for the size expressions for each dimension of an array...
Definition: CGDecl.cpp:1235
void EnsureInsertPoint()
EnsureInsertPoint - Ensure that an insertion point is defined so that emitted IR has a place to go...
body_range body()
Definition: Stmt.h:1274
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
Release the given object.
Definition: CGObjC.cpp:2172
LValue EmitDeclRefLValue(const DeclRefExpr *E)
Definition: CGExpr.cpp:2443
This represents &#39;#pragma omp declare reduction ...&#39; directive.
Definition: DeclOpenMP.h:103
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6188
static std::string getStaticDeclName(CodeGenModule &CGM, const VarDecl &D)
Definition: CGDecl.cpp:188
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
Definition: Type.h:2095
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
Definition: Decl.h:292
TypeSourceInfo * CreateTypeSourceInfo(QualType T, unsigned Size=0) const
Allocate an uninitialized TypeSourceInfo.
static void emitPartialArrayDestroy(CodeGenFunction &CGF, llvm::Value *begin, llvm::Value *end, QualType type, CharUnits elementAlign, CodeGenFunction::Destroyer *destroyer)
Perform partial array destruction as if in an EH cleanup.
Definition: CGDecl.cpp:2088
const Decl * getDecl() const
Definition: GlobalDecl.h:69
const BlockByrefInfo & getBlockByrefInfo(const VarDecl *var)
BuildByrefInfo - This routine changes a __block variable declared as T x into:
Definition: CGBlocks.cpp:2739
llvm::Value * EmitLifetimeStart(uint64_t Size, llvm::Value *Addr)
Emit a lifetime.begin marker if some criteria are satisfied.
Definition: CGDecl.cpp:1209
LangAS getStringLiteralAddressSpace() const
Return the AST address space of string literal, which is used to emit the string literal as global va...
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
static bool cxxDestructorCanThrow(QualType T)
Check if T is a C++ class that has a destructor that can throw.
Definition: CGBlocks.cpp:1811
static bool isAccessedBy(const VarDecl &var, const Stmt *s)
Definition: CGDecl.cpp:631
static void emitStoresForZeroInit(CodeGenModule &CGM, const VarDecl &D, Address Loc, bool isVolatile, CGBuilderTy &Builder)
Definition: CGDecl.cpp:1145
SanitizerSet SanOpts
Sanitizers enabled for this function.
This file defines OpenMP nodes for declarative directives.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
bool isTrivialInitializer(const Expr *Init)
Determine whether the given initializer is trivial in the sense that it requires no code to be genera...
Definition: CGDecl.cpp:1564
bool isObjCObjectPointerType() const
Definition: Type.h:6393
An aligned address.
Definition: Address.h:25
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1152
static void EmitAutoVarWithLifetime(CodeGenFunction &CGF, const VarDecl &var, Address addr, Qualifiers::ObjCLifetime lifetime)
EmitAutoVarWithLifetime - Does the setup required for an automatic variable with lifetime.
Definition: CGDecl.cpp:595
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:397
void enterByrefCleanup(CleanupKind Kind, Address Addr, BlockFieldFlags Flags, bool LoadBlockVarAddr, bool CanThrow)
Enter a cleanup to destroy a __block variable.
Definition: CGBlocks.cpp:2948
Complete object dtor.
Definition: ABI.h:36
Address CreateConstInBoundsGEP2_32(Address Addr, unsigned Idx0, unsigned Idx1, const llvm::DataLayout &DL, const llvm::Twine &Name="")
Definition: CGBuilder.h:248
void EmitParmDecl(const VarDecl &D, ParamValue Arg, unsigned ArgNo)
EmitParmDecl - Emit a ParmVarDecl or an ImplicitParamDecl.
Definition: CGDecl.cpp:2240
Assigning into this object requires a lifetime extension.
Definition: Type.h:175
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3801
QualType getType() const
Definition: CGValue.h:264
static llvm::Constant * replaceUndef(llvm::Constant *constant)
Definition: CGDecl.cpp:1173
llvm::Constant * getLLVMLifetimeEndFn()
Lazily declare the .lifetime.end intrinsic.
Definition: CGDecl.cpp:2211
void EmitDecl(const Decl &D)
EmitDecl - Emit a declaration.
Definition: CGDecl.cpp:42
const TargetCodeGenInfo & getTargetHooks() const
static Destroyer destroyARCStrongImprecise
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:215
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type, returning the result.
void addUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.used metadata.
bool isObjCGCWeak() const
true when Type is objc&#39;s weak.
Definition: Type.h:1048
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2916
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn&#39;t support the specified stmt yet.
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
CGOpenMPRuntime & getOpenMPRuntime()
Return a reference to the configured OpenMP runtime.
Dataflow Directional Tag Classes.
static ApplyDebugLocation CreateDefaultArtificial(CodeGenFunction &CGF, SourceLocation TemporaryLocation)
Apply TemporaryLocation if it is valid.
Definition: CGDebugInfo.h:722
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This)
Definition: CGClass.cpp:2389
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1262
ArrayRef< Capture > captures() const
Definition: Decl.h:3985
const CGFunctionInfo & arrangeFunctionDeclaration(const FunctionDecl *FD)
Free functions are functions that are compatible with an ordinary C function pointer type...
Definition: CGCall.cpp:437
QualType getUnderlyingType() const
Definition: Decl.h:2971
const Expr * getInit() const
Definition: Decl.h:1220
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition: CGBuilder.h:70
Kind getKind() const
Definition: DeclBase.h:421
Decl * getNonClosureContext()
Find the innermost non-closure ancestor of this declaration, walking up through blocks, lambdas, etc.
Definition: DeclBase.cpp:999
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type *> Tys=None)
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:108
static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
Definition: CGValue.h:540
bool isEscapingByref() const
Indicates the capture is a __block variable that is captured by a block that can potentially escape (...
Definition: Decl.cpp:2374
llvm::Module & getModule() const
static bool tryEmitARCCopyWeakInit(CodeGenFunction &CGF, const LValue &destLV, const Expr *init)
Definition: CGDecl.cpp:663
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type. ...
Definition: CGExprAgg.cpp:1777
static bool hasAggregateEvaluationKind(QualType T)
void EmitAutoVarCleanups(const AutoVarEmission &emission)
Definition: CGDecl.cpp:1873
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4370
bool isConstantSizeType() const
Return true if this is not a variable sized type, according to the rules of C99 6.7.5p3.
Definition: Type.cpp:2021
CodeGenTypes & getTypes() const
void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant...
Definition: Expr.cpp:2894
T * getAttr() const
Definition: DeclBase.h:527
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:52
bool isAtomicType() const
Definition: Type.h:6406
llvm::LoadInst * CreateFlagLoad(llvm::Value *Addr, const llvm::Twine &Name="")
Emit a load from an i1 flag variable.
Definition: CGBuilder.h:129
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
Definition: CGDecl.cpp:740
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the given function.
StringRef getMangledName(GlobalDecl GD)
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:32
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:443
void EmitARCInitWeak(Address addr, llvm::Value *value)
i8* @objc_initWeak(i8** addr, i8* value) Returns value.
Definition: CGObjC.cpp:2359
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3696
static Destroyer destroyNonTrivialCStruct
bool IsBypassed(const VarDecl *D) const
Returns true if the variable declaration was by bypassed by any goto or switch statement.
ARCPreciseLifetime_t
Does an ARC strong l-value have precise lifetime?
Definition: CGValue.h:120
ComplexPairTy EmitComplexExpr(const Expr *E, bool IgnoreReal=false, bool IgnoreImag=false)
EmitComplexExpr - Emit the computation of the specified expression of complex type, returning the result.
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1137
static llvm::Constant * EmitNullConstant(CodeGenModule &CGM, const RecordDecl *record, bool asCompleteObject)
Reading or writing from this object requires a barrier call.
Definition: Type.h:172
llvm::DenseMap< const VarDecl *, llvm::Value * > NRVOFlags
A mapping from NRVO variables to the flags used to indicate when the NRVO has been applied to this va...
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:6152
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
bool isNRVOVariable() const
Determine whether this local variable can be used with the named return value optimization (NRVO)...
Definition: Decl.h:1325
llvm::Type * ConvertType(QualType T)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6099
static Address createUnnamedGlobalFrom(CodeGenModule &CGM, const VarDecl &D, CGBuilderTy &Builder, llvm::Constant *Constant, CharUnits Align)
Definition: CGDecl.cpp:1051
LValue EmitLValue(const Expr *E)
EmitLValue - Emit code to compute a designator that specifies the location of the expression...
Definition: CGExpr.cpp:1236
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
bool isSamplerT() const
Definition: Type.h:6450
void pushStackRestore(CleanupKind kind, Address SPMem)
Definition: CGDecl.cpp:1964
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
Definition: Decl.h:1069
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
Definition: Sanitizers.h:52
Defines the clang::TargetInfo interface.
void finalize(llvm::GlobalVariable *global)
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Definition: TargetCXXABI.h:154
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:276
void setLocation(SourceLocation Loc)
Update the current source location.
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1041
static RValue get(llvm::Value *V)
Definition: CGValue.h:86
void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr)
Definition: CGDecl.cpp:1225
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
llvm::Constant * EmitCheckSourceLocation(SourceLocation Loc)
Emit a description of a source location in a format suitable for passing to a runtime sanitizer handl...
Definition: CGExpr.cpp:2791
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
Definition: Decl.h:1105
QualType getType() const
Definition: Decl.h:648
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:114
LValue - This represents an lvalue references.
Definition: CGValue.h:167
Information for lazily generating a cleanup.
Definition: EHScopeStack.h:147
void EmitVarAnnotations(const VarDecl *D, llvm::Value *V)
Emit local annotations for the local variable V, declared by D.
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2971
Automatic storage duration (most local variables).
Definition: Specifiers.h:279
SanitizerMetadata * getSanitizerMetadata()
bool isConstant(const ASTContext &Ctx) const
Definition: Type.h:773
bool CurFuncIsThunk
In C++, whether we are code generating a thunk.
const LangOptions & getLangOpts() const
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.h:2499
llvm::Value * emitArrayLength(const ArrayType *arrayType, QualType &baseType, Address &addr)
emitArrayLength - Compute the length of an array, even if it&#39;s a VLA, and drill down to the base elem...
CallArgList - Type for representing both the value and type of arguments in a call.
Definition: CGCall.h:260
const LangOptions & getLangOpts() const
Definition: ASTContext.h:707
void PopCleanupBlock(bool FallThroughIsBranchThrough=false)
PopCleanupBlock - Will pop the cleanup entry on the stack and process all branch fixups.
Definition: CGCleanup.cpp:651
llvm::Value * getPointer() const
Definition: CGValue.h:323
Address emitBlockByrefAddress(Address baseAddr, const VarDecl *V, bool followForward=true)
BuildBlockByrefAddress - Computes the location of the data in a variable which is declared as __block...
Definition: CGBlocks.cpp:2702
SourceLocation getLocation() const
Definition: DeclBase.h:418
void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin, Address arrayEndPointer, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)
pushIrregularPartialArrayCleanup - Push an EH cleanup to destroy already-constructed elements of the ...
Definition: CGDecl.cpp:2173
bool isExternallyVisible() const
Definition: Decl.h:380
QualType getIntTypeForBitwidth(unsigned DestWidth, unsigned Signed) const
getIntTypeForBitwidth - sets integer QualTy according to specified details: bitwidth, signed/unsigned.
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2560
void Destroyer(CodeGenFunction &CGF, Address addr, QualType ty)
static CharUnits getDeclAlign(Expr *E, CharUnits TypeAlign, ASTContext &Context)
A helper function to get the alignment of a Decl referred to by DeclRefExpr or MemberExpr.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1058