clang  8.0.0svn
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"
30 #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(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(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 ExprWithCleanups *ewc = dyn_cast<ExprWithCleanups>(init)) {
758  enterFullExpression(ewc);
759  init = ewc->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 
801  value = EmitARCUnsafeUnretainedScalarExpr(init);
802  break;
803 
804  case Qualifiers::OCL_Strong: {
805  value = EmitARCRetainScalarExpr(init);
806  break;
807  }
808 
809  case Qualifiers::OCL_Weak: {
810  // If it's not accessed by the initializer, try to emit the
811  // initialization with a copy or move.
812  if (!accessedByInit && tryEmitARCCopyWeakInit(*this, lvalue, init)) {
813  return;
814  }
815 
816  // No way to optimize a producing initializer into this. It's not
817  // worth optimizing for, because the value will immediately
818  // disappear in the common case.
819  value = EmitScalarExpr(init);
820 
821  if (capturedByInit) drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
822  if (accessedByInit)
823  EmitARCStoreWeak(lvalue.getAddress(), value, /*ignored*/ true);
824  else
825  EmitARCInitWeak(lvalue.getAddress(), value);
826  return;
827  }
828 
831  break;
832  }
833 
834  if (capturedByInit) drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
835 
836  EmitNullabilityCheck(lvalue, value, init->getExprLoc());
837 
838  // If the variable might have been accessed by its initializer, we
839  // might have to initialize with a barrier. We have to do this for
840  // both __weak and __strong, but __weak got filtered out above.
841  if (accessedByInit && lifetime == Qualifiers::OCL_Strong) {
842  llvm::Value *oldValue = EmitLoadOfScalar(lvalue, init->getExprLoc());
843  EmitStoreOfScalar(value, lvalue, /* isInitialization */ true);
845  return;
846  }
847 
848  EmitStoreOfScalar(value, lvalue, /* isInitialization */ true);
849 }
850 
851 /// Decide whether we can emit the non-zero parts of the specified initializer
852 /// with equal or fewer than NumStores scalar stores.
853 static bool canEmitInitWithFewStoresAfterBZero(llvm::Constant *Init,
854  unsigned &NumStores) {
855  // Zero and Undef never requires any extra stores.
856  if (isa<llvm::ConstantAggregateZero>(Init) ||
857  isa<llvm::ConstantPointerNull>(Init) ||
858  isa<llvm::UndefValue>(Init))
859  return true;
860  if (isa<llvm::ConstantInt>(Init) || isa<llvm::ConstantFP>(Init) ||
861  isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
862  isa<llvm::ConstantExpr>(Init))
863  return Init->isNullValue() || NumStores--;
864 
865  // See if we can emit each element.
866  if (isa<llvm::ConstantArray>(Init) || isa<llvm::ConstantStruct>(Init)) {
867  for (unsigned i = 0, e = Init->getNumOperands(); i != e; ++i) {
868  llvm::Constant *Elt = cast<llvm::Constant>(Init->getOperand(i));
869  if (!canEmitInitWithFewStoresAfterBZero(Elt, NumStores))
870  return false;
871  }
872  return true;
873  }
874 
875  if (llvm::ConstantDataSequential *CDS =
876  dyn_cast<llvm::ConstantDataSequential>(Init)) {
877  for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
878  llvm::Constant *Elt = CDS->getElementAsConstant(i);
879  if (!canEmitInitWithFewStoresAfterBZero(Elt, NumStores))
880  return false;
881  }
882  return true;
883  }
884 
885  // Anything else is hard and scary.
886  return false;
887 }
888 
889 /// For inits that canEmitInitWithFewStoresAfterBZero returned true for, emit
890 /// the scalar stores that would be required.
892  llvm::Constant *Init, Address Loc,
893  bool isVolatile, CGBuilderTy &Builder) {
894  assert(!Init->isNullValue() && !isa<llvm::UndefValue>(Init) &&
895  "called emitStoresForInitAfterBZero for zero or undef value.");
896 
897  if (isa<llvm::ConstantInt>(Init) || isa<llvm::ConstantFP>(Init) ||
898  isa<llvm::ConstantVector>(Init) || isa<llvm::BlockAddress>(Init) ||
899  isa<llvm::ConstantExpr>(Init)) {
900  Builder.CreateStore(Init, Loc, isVolatile);
901  return;
902  }
903 
904  if (llvm::ConstantDataSequential *CDS =
905  dyn_cast<llvm::ConstantDataSequential>(Init)) {
906  for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
907  llvm::Constant *Elt = CDS->getElementAsConstant(i);
908 
909  // If necessary, get a pointer to the element and emit it.
910  if (!Elt->isNullValue() && !isa<llvm::UndefValue>(Elt))
912  CGM, Elt,
913  Builder.CreateConstInBoundsGEP2_32(Loc, 0, i, CGM.getDataLayout()),
914  isVolatile, Builder);
915  }
916  return;
917  }
918 
919  assert((isa<llvm::ConstantStruct>(Init) || isa<llvm::ConstantArray>(Init)) &&
920  "Unknown value type!");
921 
922  for (unsigned i = 0, e = Init->getNumOperands(); i != e; ++i) {
923  llvm::Constant *Elt = cast<llvm::Constant>(Init->getOperand(i));
924 
925  // If necessary, get a pointer to the element and emit it.
926  if (!Elt->isNullValue() && !isa<llvm::UndefValue>(Elt))
928  CGM, Elt,
929  Builder.CreateConstInBoundsGEP2_32(Loc, 0, i, CGM.getDataLayout()),
930  isVolatile, Builder);
931  }
932 }
933 
934 /// Decide whether we should use bzero plus some stores to initialize a local
935 /// variable instead of using a memcpy from a constant global. It is beneficial
936 /// to use bzero if the global is all zeros, or mostly zeros and large.
937 static bool shouldUseBZeroPlusStoresToInitialize(llvm::Constant *Init,
938  uint64_t GlobalSize) {
939  // If a global is all zeros, always use a bzero.
940  if (isa<llvm::ConstantAggregateZero>(Init)) return true;
941 
942  // If a non-zero global is <= 32 bytes, always use a memcpy. If it is large,
943  // do it if it will require 6 or fewer scalar stores.
944  // TODO: Should budget depends on the size? Avoiding a large global warrants
945  // plopping in more stores.
946  unsigned StoreBudget = 6;
947  uint64_t SizeLimit = 32;
948 
949  return GlobalSize > SizeLimit &&
950  canEmitInitWithFewStoresAfterBZero(Init, StoreBudget);
951 }
952 
953 /// Decide whether we should use memset to initialize a local variable instead
954 /// of using a memcpy from a constant global. Assumes we've already decided to
955 /// not user bzero.
956 /// FIXME We could be more clever, as we are for bzero above, and generate
957 /// memset followed by stores. It's unclear that's worth the effort.
958 static llvm::Value *shouldUseMemSetToInitialize(llvm::Constant *Init,
959  uint64_t GlobalSize) {
960  uint64_t SizeLimit = 32;
961  if (GlobalSize <= SizeLimit)
962  return nullptr;
963  return llvm::isBytewiseValue(Init);
964 }
965 
967  Address Loc, bool isVolatile,
969  llvm::Constant *constant) {
970  auto *Int8Ty = llvm::IntegerType::getInt8Ty(CGM.getLLVMContext());
971  auto *IntPtrTy = CGM.getDataLayout().getIntPtrType(CGM.getLLVMContext());
972 
973  // If the initializer is all or mostly the same, codegen with bzero / memset
974  // then do a few stores afterward.
975  uint64_t ConstantSize =
976  CGM.getDataLayout().getTypeAllocSize(constant->getType());
977  auto *SizeVal = llvm::ConstantInt::get(IntPtrTy, ConstantSize);
978  if (shouldUseBZeroPlusStoresToInitialize(constant, ConstantSize)) {
979  Builder.CreateMemSet(Loc, llvm::ConstantInt::get(Int8Ty, 0), SizeVal,
980  isVolatile);
981 
982  bool valueAlreadyCorrect =
983  constant->isNullValue() || isa<llvm::UndefValue>(constant);
984  if (!valueAlreadyCorrect) {
985  Loc = Builder.CreateBitCast(
986  Loc, constant->getType()->getPointerTo(Loc.getAddressSpace()));
987  emitStoresForInitAfterBZero(CGM, constant, Loc, isVolatile, Builder);
988  }
989  return;
990  }
991 
992  llvm::Value *Pattern = shouldUseMemSetToInitialize(constant, ConstantSize);
993  if (Pattern) {
994  uint64_t Value = 0x00;
995  if (!isa<llvm::UndefValue>(Pattern)) {
996  const llvm::APInt &AP = cast<llvm::ConstantInt>(Pattern)->getValue();
997  assert(AP.getBitWidth() <= 8);
998  Value = AP.getLimitedValue();
999  }
1000  Builder.CreateMemSet(Loc, llvm::ConstantInt::get(Int8Ty, Value), SizeVal,
1001  isVolatile);
1002  return;
1003  }
1004 
1005  // Otherwise, create a temporary global with the initializer then memcpy from
1006  // the global to the alloca.
1007  std::string Name = getStaticDeclName(CGM, D);
1008  unsigned AS = CGM.getContext().getTargetAddressSpace(
1010  llvm::Type *BP = llvm::PointerType::getInt8PtrTy(CGM.getLLVMContext(), AS);
1011 
1012  llvm::GlobalVariable *GV = new llvm::GlobalVariable(
1013  CGM.getModule(), constant->getType(), true,
1014  llvm::GlobalValue::PrivateLinkage, constant, Name, nullptr,
1015  llvm::GlobalValue::NotThreadLocal, AS);
1016  GV->setAlignment(Loc.getAlignment().getQuantity());
1017  GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1018 
1019  Address SrcPtr = Address(GV, Loc.getAlignment());
1020  if (SrcPtr.getType() != BP)
1021  SrcPtr = Builder.CreateBitCast(SrcPtr, BP);
1022 
1023  Builder.CreateMemCpy(Loc, SrcPtr, SizeVal, isVolatile);
1024 }
1025 
1026 /// EmitAutoVarDecl - Emit code and set up an entry in LocalDeclMap for a
1027 /// variable declaration with auto, register, or no storage class specifier.
1028 /// These turn into simple stack objects, or GlobalValues depending on target.
1030  AutoVarEmission emission = EmitAutoVarAlloca(D);
1031  EmitAutoVarInit(emission);
1032  EmitAutoVarCleanups(emission);
1033 }
1034 
1035 /// Emit a lifetime.begin marker if some criteria are satisfied.
1036 /// \return a pointer to the temporary size Value if a marker was emitted, null
1037 /// otherwise
1039  llvm::Value *Addr) {
1040  if (!ShouldEmitLifetimeMarkers)
1041  return nullptr;
1042 
1043  assert(Addr->getType()->getPointerAddressSpace() ==
1044  CGM.getDataLayout().getAllocaAddrSpace() &&
1045  "Pointer should be in alloca address space");
1046  llvm::Value *SizeV = llvm::ConstantInt::get(Int64Ty, Size);
1047  Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
1048  llvm::CallInst *C =
1049  Builder.CreateCall(CGM.getLLVMLifetimeStartFn(), {SizeV, Addr});
1050  C->setDoesNotThrow();
1051  return SizeV;
1052 }
1053 
1055  assert(Addr->getType()->getPointerAddressSpace() ==
1056  CGM.getDataLayout().getAllocaAddrSpace() &&
1057  "Pointer should be in alloca address space");
1058  Addr = Builder.CreateBitCast(Addr, AllocaInt8PtrTy);
1059  llvm::CallInst *C =
1060  Builder.CreateCall(CGM.getLLVMLifetimeEndFn(), {Size, Addr});
1061  C->setDoesNotThrow();
1062 }
1063 
1065  CGDebugInfo *DI, const VarDecl &D, bool EmitDebugInfo) {
1066  // For each dimension stores its QualType and corresponding
1067  // size-expression Value.
1069 
1070  // Break down the array into individual dimensions.
1071  QualType Type1D = D.getType();
1072  while (getContext().getAsVariableArrayType(Type1D)) {
1073  auto VlaSize = getVLAElements1D(Type1D);
1074  if (auto *C = dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))
1075  Dimensions.emplace_back(C, Type1D.getUnqualifiedType());
1076  else {
1077  auto SizeExprAddr = CreateDefaultAlignTempAlloca(
1078  VlaSize.NumElts->getType(), "__vla_expr");
1079  Builder.CreateStore(VlaSize.NumElts, SizeExprAddr);
1080  Dimensions.emplace_back(SizeExprAddr.getPointer(),
1081  Type1D.getUnqualifiedType());
1082  }
1083  Type1D = VlaSize.Type;
1084  }
1085 
1086  if (!EmitDebugInfo)
1087  return;
1088 
1089  // Register each dimension's size-expression with a DILocalVariable,
1090  // so that it can be used by CGDebugInfo when instantiating a DISubrange
1091  // to describe this array.
1092  for (auto &VlaSize : Dimensions) {
1093  llvm::Metadata *MD;
1094  if (auto *C = dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))
1095  MD = llvm::ConstantAsMetadata::get(C);
1096  else {
1097  // Create an artificial VarDecl to generate debug info for.
1098  IdentifierInfo &NameIdent = getContext().Idents.getOwn(
1099  cast<llvm::AllocaInst>(VlaSize.NumElts)->getName());
1100  auto VlaExprTy = VlaSize.NumElts->getType()->getPointerElementType();
1101  auto QT = getContext().getIntTypeForBitwidth(
1102  VlaExprTy->getScalarSizeInBits(), false);
1103  auto *ArtificialDecl = VarDecl::Create(
1104  getContext(), const_cast<DeclContext *>(D.getDeclContext()),
1105  D.getLocation(), D.getLocation(), &NameIdent, QT,
1107  ArtificialDecl->setImplicit();
1108 
1109  MD = DI->EmitDeclareOfAutoVariable(ArtificialDecl, VlaSize.NumElts,
1110  Builder);
1111  }
1112  assert(MD && "No Size expression debug node created");
1113  DI->registerVLASizeExpression(VlaSize.Type, MD);
1114  }
1115 }
1116 
1117 /// EmitAutoVarAlloca - Emit the alloca and debug information for a
1118 /// local variable. Does not emit initialization or destruction.
1121  QualType Ty = D.getType();
1122  assert(
1123  Ty.getAddressSpace() == LangAS::Default ||
1124  (Ty.getAddressSpace() == LangAS::opencl_private && getLangOpts().OpenCL));
1125 
1126  AutoVarEmission emission(D);
1127 
1128  bool isEscapingByRef = D.isEscapingByref();
1129  emission.IsEscapingByRef = isEscapingByRef;
1130 
1131  CharUnits alignment = getContext().getDeclAlign(&D);
1132 
1133  // If the type is variably-modified, emit all the VLA sizes for it.
1134  if (Ty->isVariablyModifiedType())
1136 
1137  auto *DI = getDebugInfo();
1138  bool EmitDebugInfo = DI && CGM.getCodeGenOpts().getDebugInfo() >=
1140 
1141  Address address = Address::invalid();
1142  Address AllocaAddr = Address::invalid();
1143  if (Ty->isConstantSizeType()) {
1144  bool NRVO = getLangOpts().ElideConstructors &&
1145  D.isNRVOVariable();
1146 
1147  // If this value is an array or struct with a statically determinable
1148  // constant initializer, there are optimizations we can do.
1149  //
1150  // TODO: We should constant-evaluate the initializer of any variable,
1151  // as long as it is initialized by a constant expression. Currently,
1152  // isConstantInitializer produces wrong answers for structs with
1153  // reference or bitfield members, and a few other cases, and checking
1154  // for POD-ness protects us from some of these.
1155  if (D.getInit() && (Ty->isArrayType() || Ty->isRecordType()) &&
1156  (D.isConstexpr() ||
1157  ((Ty.isPODType(getContext()) ||
1159  D.getInit()->isConstantInitializer(getContext(), false)))) {
1160 
1161  // If the variable's a const type, and it's neither an NRVO
1162  // candidate nor a __block variable and has no mutable members,
1163  // emit it as a global instead.
1164  // Exception is if a variable is located in non-constant address space
1165  // in OpenCL.
1166  if ((!getLangOpts().OpenCL ||
1168  (CGM.getCodeGenOpts().MergeAllConstants && !NRVO &&
1169  !isEscapingByRef && CGM.isTypeConstant(Ty, true))) {
1171 
1172  // Signal this condition to later callbacks.
1173  emission.Addr = Address::invalid();
1174  assert(emission.wasEmittedAsGlobal());
1175  return emission;
1176  }
1177 
1178  // Otherwise, tell the initialization code that we're in this case.
1179  emission.IsConstantAggregate = true;
1180  }
1181 
1182  // A normal fixed sized variable becomes an alloca in the entry block,
1183  // unless:
1184  // - it's an NRVO variable.
1185  // - we are compiling OpenMP and it's an OpenMP local variable.
1186 
1187  Address OpenMPLocalAddr =
1188  getLangOpts().OpenMP
1189  ? CGM.getOpenMPRuntime().getAddressOfLocalVariable(*this, &D)
1190  : Address::invalid();
1191  if (getLangOpts().OpenMP && OpenMPLocalAddr.isValid()) {
1192  address = OpenMPLocalAddr;
1193  } else if (NRVO) {
1194  // The named return value optimization: allocate this variable in the
1195  // return slot, so that we can elide the copy when returning this
1196  // variable (C++0x [class.copy]p34).
1197  address = ReturnValue;
1198 
1199  if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
1200  const auto *RD = RecordTy->getDecl();
1201  const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD);
1202  if ((CXXRD && !CXXRD->hasTrivialDestructor()) ||
1203  RD->isNonTrivialToPrimitiveDestroy()) {
1204  // Create a flag that is used to indicate when the NRVO was applied
1205  // to this variable. Set it to zero to indicate that NRVO was not
1206  // applied.
1207  llvm::Value *Zero = Builder.getFalse();
1208  Address NRVOFlag =
1209  CreateTempAlloca(Zero->getType(), CharUnits::One(), "nrvo");
1211  Builder.CreateStore(Zero, NRVOFlag);
1212 
1213  // Record the NRVO flag for this variable.
1214  NRVOFlags[&D] = NRVOFlag.getPointer();
1215  emission.NRVOFlag = NRVOFlag.getPointer();
1216  }
1217  }
1218  } else {
1219  CharUnits allocaAlignment;
1220  llvm::Type *allocaTy;
1221  if (isEscapingByRef) {
1222  auto &byrefInfo = getBlockByrefInfo(&D);
1223  allocaTy = byrefInfo.Type;
1224  allocaAlignment = byrefInfo.ByrefAlignment;
1225  } else {
1226  allocaTy = ConvertTypeForMem(Ty);
1227  allocaAlignment = alignment;
1228  }
1229 
1230  // Create the alloca. Note that we set the name separately from
1231  // building the instruction so that it's there even in no-asserts
1232  // builds.
1233  address = CreateTempAlloca(allocaTy, allocaAlignment, D.getName(),
1234  /*ArraySize=*/nullptr, &AllocaAddr);
1235 
1236  // Don't emit lifetime markers for MSVC catch parameters. The lifetime of
1237  // the catch parameter starts in the catchpad instruction, and we can't
1238  // insert code in those basic blocks.
1239  bool IsMSCatchParam =
1241 
1242  // Emit a lifetime intrinsic if meaningful. There's no point in doing this
1243  // if we don't have a valid insertion point (?).
1244  if (HaveInsertPoint() && !IsMSCatchParam) {
1245  // If there's a jump into the lifetime of this variable, its lifetime
1246  // gets broken up into several regions in IR, which requires more work
1247  // to handle correctly. For now, just omit the intrinsics; this is a
1248  // rare case, and it's better to just be conservatively correct.
1249  // PR28267.
1250  //
1251  // We have to do this in all language modes if there's a jump past the
1252  // declaration. We also have to do it in C if there's a jump to an
1253  // earlier point in the current block because non-VLA lifetimes begin as
1254  // soon as the containing block is entered, not when its variables
1255  // actually come into scope; suppressing the lifetime annotations
1256  // completely in this case is unnecessarily pessimistic, but again, this
1257  // is rare.
1258  if (!Bypasses.IsBypassed(&D) &&
1259  !(!getLangOpts().CPlusPlus && hasLabelBeenSeenInCurrentScope())) {
1260  uint64_t size = CGM.getDataLayout().getTypeAllocSize(allocaTy);
1261  emission.SizeForLifetimeMarkers =
1262  EmitLifetimeStart(size, AllocaAddr.getPointer());
1263  }
1264  } else {
1265  assert(!emission.useLifetimeMarkers());
1266  }
1267  }
1268  } else {
1270 
1271  if (!DidCallStackSave) {
1272  // Save the stack.
1273  Address Stack =
1274  CreateTempAlloca(Int8PtrTy, getPointerAlign(), "saved_stack");
1275 
1276  llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::stacksave);
1277  llvm::Value *V = Builder.CreateCall(F);
1278  Builder.CreateStore(V, Stack);
1279 
1280  DidCallStackSave = true;
1281 
1282  // Push a cleanup block and restore the stack there.
1283  // FIXME: in general circumstances, this should be an EH cleanup.
1285  }
1286 
1287  auto VlaSize = getVLASize(Ty);
1288  llvm::Type *llvmTy = ConvertTypeForMem(VlaSize.Type);
1289 
1290  // Allocate memory for the array.
1291  address = CreateTempAlloca(llvmTy, alignment, "vla", VlaSize.NumElts,
1292  &AllocaAddr);
1293 
1294  // If we have debug info enabled, properly describe the VLA dimensions for
1295  // this type by registering the vla size expression for each of the
1296  // dimensions.
1297  EmitAndRegisterVariableArrayDimensions(DI, D, EmitDebugInfo);
1298  }
1299 
1300  setAddrOfLocalVar(&D, address);
1301  emission.Addr = address;
1302  emission.AllocaAddr = AllocaAddr;
1303 
1304  // Emit debug info for local var declaration.
1305  if (EmitDebugInfo && HaveInsertPoint()) {
1306  DI->setLocation(D.getLocation());
1307  (void)DI->EmitDeclareOfAutoVariable(&D, address.getPointer(), Builder);
1308  }
1309 
1310  if (D.hasAttr<AnnotateAttr>())
1311  EmitVarAnnotations(&D, address.getPointer());
1312 
1313  // Make sure we call @llvm.lifetime.end.
1314  if (emission.useLifetimeMarkers())
1316  emission.getOriginalAllocatedAddress(),
1317  emission.getSizeForLifetimeMarkers());
1318 
1319  return emission;
1320 }
1321 
1322 static bool isCapturedBy(const VarDecl &, const Expr *);
1323 
1324 /// Determines whether the given __block variable is potentially
1325 /// captured by the given statement.
1326 static bool isCapturedBy(const VarDecl &Var, const Stmt *S) {
1327  if (const Expr *E = dyn_cast<Expr>(S))
1328  return isCapturedBy(Var, E);
1329  for (const Stmt *SubStmt : S->children())
1330  if (isCapturedBy(Var, SubStmt))
1331  return true;
1332  return false;
1333 }
1334 
1335 /// Determines whether the given __block variable is potentially
1336 /// captured by the given expression.
1337 static bool isCapturedBy(const VarDecl &Var, const Expr *E) {
1338  // Skip the most common kinds of expressions that make
1339  // hierarchy-walking expensive.
1340  E = E->IgnoreParenCasts();
1341 
1342  if (const BlockExpr *BE = dyn_cast<BlockExpr>(E)) {
1343  const BlockDecl *Block = BE->getBlockDecl();
1344  for (const auto &I : Block->captures()) {
1345  if (I.getVariable() == &Var)
1346  return true;
1347  }
1348 
1349  // No need to walk into the subexpressions.
1350  return false;
1351  }
1352 
1353  if (const StmtExpr *SE = dyn_cast<StmtExpr>(E)) {
1354  const CompoundStmt *CS = SE->getSubStmt();
1355  for (const auto *BI : CS->body())
1356  if (const auto *BIE = dyn_cast<Expr>(BI)) {
1357  if (isCapturedBy(Var, BIE))
1358  return true;
1359  }
1360  else if (const auto *DS = dyn_cast<DeclStmt>(BI)) {
1361  // special case declarations
1362  for (const auto *I : DS->decls()) {
1363  if (const auto *VD = dyn_cast<VarDecl>((I))) {
1364  const Expr *Init = VD->getInit();
1365  if (Init && isCapturedBy(Var, Init))
1366  return true;
1367  }
1368  }
1369  }
1370  else
1371  // FIXME. Make safe assumption assuming arbitrary statements cause capturing.
1372  // Later, provide code to poke into statements for capture analysis.
1373  return true;
1374  return false;
1375  }
1376 
1377  for (const Stmt *SubStmt : E->children())
1378  if (isCapturedBy(Var, SubStmt))
1379  return true;
1380 
1381  return false;
1382 }
1383 
1384 /// Determine whether the given initializer is trivial in the sense
1385 /// that it requires no code to be generated.
1387  if (!Init)
1388  return true;
1389 
1390  if (const CXXConstructExpr *Construct = dyn_cast<CXXConstructExpr>(Init))
1391  if (CXXConstructorDecl *Constructor = Construct->getConstructor())
1392  if (Constructor->isTrivial() &&
1393  Constructor->isDefaultConstructor() &&
1394  !Construct->requiresZeroInitialization())
1395  return true;
1396 
1397  return false;
1398 }
1399 
1401  assert(emission.Variable && "emission was not valid!");
1402 
1403  // If this was emitted as a global constant, we're done.
1404  if (emission.wasEmittedAsGlobal()) return;
1405 
1406  const VarDecl &D = *emission.Variable;
1408  QualType type = D.getType();
1409 
1410  // If this local has an initializer, emit it now.
1411  const Expr *Init = D.getInit();
1412 
1413  // If we are at an unreachable point, we don't need to emit the initializer
1414  // unless it contains a label.
1415  if (!HaveInsertPoint()) {
1416  if (!Init || !ContainsLabel(Init)) return;
1418  }
1419 
1420  // Initialize the structure of a __block variable.
1421  if (emission.IsEscapingByRef)
1422  emitByrefStructureInit(emission);
1423 
1424  // Initialize the variable here if it doesn't have a initializer and it is a
1425  // C struct that is non-trivial to initialize or an array containing such a
1426  // struct.
1427  if (!Init &&
1428  type.isNonTrivialToPrimitiveDefaultInitialize() ==
1430  LValue Dst = MakeAddrLValue(emission.getAllocatedAddress(), type);
1431  if (emission.IsEscapingByRef)
1432  drillIntoBlockVariable(*this, Dst, &D);
1434  return;
1435  }
1436 
1437  if (isTrivialInitializer(Init))
1438  return;
1439 
1440  // Check whether this is a byref variable that's potentially
1441  // captured and moved by its own initializer. If so, we'll need to
1442  // emit the initializer first, then copy into the variable.
1443  bool capturedByInit = emission.IsEscapingByRef && isCapturedBy(D, Init);
1444 
1445  Address Loc =
1446  capturedByInit ? emission.Addr : emission.getObjectAddress(*this);
1447 
1448  llvm::Constant *constant = nullptr;
1449  if (emission.IsConstantAggregate || D.isConstexpr()) {
1450  assert(!capturedByInit && "constant init contains a capturing block?");
1451  constant = ConstantEmitter(*this).tryEmitAbstractForInitializer(D);
1452  }
1453 
1454  if (!constant) {
1455  LValue lv = MakeAddrLValue(Loc, type);
1456  lv.setNonGC(true);
1457  return EmitExprAsInit(Init, &D, lv, capturedByInit);
1458  }
1459 
1460  if (!emission.IsConstantAggregate) {
1461  // For simple scalar/complex initialization, store the value directly.
1462  LValue lv = MakeAddrLValue(Loc, type);
1463  lv.setNonGC(true);
1464  return EmitStoreThroughLValue(RValue::get(constant), lv, true);
1465  }
1466 
1467  // If this is a simple aggregate initialization, we can optimize it
1468  // in various ways.
1469  bool isVolatile = type.isVolatileQualified();
1470 
1471  llvm::Type *BP = CGM.Int8Ty->getPointerTo(Loc.getAddressSpace());
1472  if (Loc.getType() != BP)
1473  Loc = Builder.CreateBitCast(Loc, BP);
1474 
1475  emitStoresForConstant(CGM, D, Loc, isVolatile, Builder, constant);
1476 }
1477 
1478 /// Emit an expression as an initializer for an object (variable, field, etc.)
1479 /// at the given location. The expression is not necessarily the normal
1480 /// initializer for the object, and the address is not necessarily
1481 /// its normal location.
1482 ///
1483 /// \param init the initializing expression
1484 /// \param D the object to act as if we're initializing
1485 /// \param loc the address to initialize; its type is a pointer
1486 /// to the LLVM mapping of the object's type
1487 /// \param alignment the alignment of the address
1488 /// \param capturedByInit true if \p D is a __block variable
1489 /// whose address is potentially changed by the initializer
1491  LValue lvalue, bool capturedByInit) {
1492  QualType type = D->getType();
1493 
1494  if (type->isReferenceType()) {
1495  RValue rvalue = EmitReferenceBindingToExpr(init);
1496  if (capturedByInit)
1497  drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
1498  EmitStoreThroughLValue(rvalue, lvalue, true);
1499  return;
1500  }
1501  switch (getEvaluationKind(type)) {
1502  case TEK_Scalar:
1503  EmitScalarInit(init, D, lvalue, capturedByInit);
1504  return;
1505  case TEK_Complex: {
1506  ComplexPairTy complex = EmitComplexExpr(init);
1507  if (capturedByInit)
1508  drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
1509  EmitStoreOfComplex(complex, lvalue, /*init*/ true);
1510  return;
1511  }
1512  case TEK_Aggregate:
1513  if (type->isAtomicType()) {
1514  EmitAtomicInit(const_cast<Expr*>(init), lvalue);
1515  } else {
1517  if (isa<VarDecl>(D))
1518  Overlap = AggValueSlot::DoesNotOverlap;
1519  else if (auto *FD = dyn_cast<FieldDecl>(D))
1520  Overlap = overlapForFieldInit(FD);
1521  // TODO: how can we delay here if D is captured by its initializer?
1522  EmitAggExpr(init, AggValueSlot::forLValue(lvalue,
1526  Overlap));
1527  }
1528  return;
1529  }
1530  llvm_unreachable("bad evaluation kind");
1531 }
1532 
1533 /// Enter a destroy cleanup for the given local variable.
1535  const CodeGenFunction::AutoVarEmission &emission,
1536  QualType::DestructionKind dtorKind) {
1537  assert(dtorKind != QualType::DK_none);
1538 
1539  // Note that for __block variables, we want to destroy the
1540  // original stack object, not the possibly forwarded object.
1541  Address addr = emission.getObjectAddress(*this);
1542 
1543  const VarDecl *var = emission.Variable;
1544  QualType type = var->getType();
1545 
1546  CleanupKind cleanupKind = NormalAndEHCleanup;
1547  CodeGenFunction::Destroyer *destroyer = nullptr;
1548 
1549  switch (dtorKind) {
1550  case QualType::DK_none:
1551  llvm_unreachable("no cleanup for trivially-destructible variable");
1552 
1554  // If there's an NRVO flag on the emission, we need a different
1555  // cleanup.
1556  if (emission.NRVOFlag) {
1557  assert(!type->isArrayType());
1559  EHStack.pushCleanup<DestroyNRVOVariableCXX>(cleanupKind, addr, dtor,
1560  emission.NRVOFlag);
1561  return;
1562  }
1563  break;
1564 
1566  // Suppress cleanups for pseudo-strong variables.
1567  if (var->isARCPseudoStrong()) return;
1568 
1569  // Otherwise, consider whether to use an EH cleanup or not.
1570  cleanupKind = getARCCleanupKind();
1571 
1572  // Use the imprecise destroyer by default.
1573  if (!var->hasAttr<ObjCPreciseLifetimeAttr>())
1575  break;
1576 
1578  break;
1579 
1582  if (emission.NRVOFlag) {
1583  assert(!type->isArrayType());
1584  EHStack.pushCleanup<DestroyNRVOVariableC>(cleanupKind, addr,
1585  emission.NRVOFlag, type);
1586  return;
1587  }
1588  break;
1589  }
1590 
1591  // If we haven't chosen a more specific destroyer, use the default.
1592  if (!destroyer) destroyer = getDestroyer(dtorKind);
1593 
1594  // Use an EH cleanup in array destructors iff the destructor itself
1595  // is being pushed as an EH cleanup.
1596  bool useEHCleanup = (cleanupKind & EHCleanup);
1597  EHStack.pushCleanup<DestroyObject>(cleanupKind, addr, type, destroyer,
1598  useEHCleanup);
1599 }
1600 
1602  assert(emission.Variable && "emission was not valid!");
1603 
1604  // If this was emitted as a global constant, we're done.
1605  if (emission.wasEmittedAsGlobal()) return;
1606 
1607  // If we don't have an insertion point, we're done. Sema prevents
1608  // us from jumping into any of these scopes anyway.
1609  if (!HaveInsertPoint()) return;
1610 
1611  const VarDecl &D = *emission.Variable;
1612 
1613  // Check the type for a cleanup.
1614  if (QualType::DestructionKind dtorKind = D.getType().isDestructedType())
1615  emitAutoVarTypeCleanup(emission, dtorKind);
1616 
1617  // In GC mode, honor objc_precise_lifetime.
1618  if (getLangOpts().getGC() != LangOptions::NonGC &&
1619  D.hasAttr<ObjCPreciseLifetimeAttr>()) {
1620  EHStack.pushCleanup<ExtendGCLifetime>(NormalCleanup, &D);
1621  }
1622 
1623  // Handle the cleanup attribute.
1624  if (const CleanupAttr *CA = D.getAttr<CleanupAttr>()) {
1625  const FunctionDecl *FD = CA->getFunctionDecl();
1626 
1627  llvm::Constant *F = CGM.GetAddrOfFunction(FD);
1628  assert(F && "Could not find function!");
1629 
1631  EHStack.pushCleanup<CallCleanupFunction>(NormalAndEHCleanup, F, &Info, &D);
1632  }
1633 
1634  // If this is a block variable, call _Block_object_destroy
1635  // (on the unforwarded address). Don't enter this cleanup if we're in pure-GC
1636  // mode.
1637  if (emission.IsEscapingByRef &&
1638  CGM.getLangOpts().getGC() != LangOptions::GCOnly) {
1640  if (emission.Variable->getType().isObjCGCWeak())
1641  Flags |= BLOCK_FIELD_IS_WEAK;
1642  enterByrefCleanup(NormalAndEHCleanup, emission.Addr, Flags,
1643  /*LoadBlockVarAddr*/ false,
1644  cxxDestructorCanThrow(emission.Variable->getType()));
1645  }
1646 }
1647 
1650  switch (kind) {
1651  case QualType::DK_none: llvm_unreachable("no destroyer for trivial dtor");
1653  return destroyCXXObject;
1655  return destroyARCStrongPrecise;
1657  return destroyARCWeak;
1659  return destroyNonTrivialCStruct;
1660  }
1661  llvm_unreachable("Unknown DestructionKind");
1662 }
1663 
1664 /// pushEHDestroy - Push the standard destructor for the given type as
1665 /// an EH-only cleanup.
1667  Address addr, QualType type) {
1668  assert(dtorKind && "cannot push destructor for trivial type");
1669  assert(needsEHCleanup(dtorKind));
1670 
1671  pushDestroy(EHCleanup, addr, type, getDestroyer(dtorKind), true);
1672 }
1673 
1674 /// pushDestroy - Push the standard destructor for the given type as
1675 /// at least a normal cleanup.
1677  Address addr, QualType type) {
1678  assert(dtorKind && "cannot push destructor for trivial type");
1679 
1680  CleanupKind cleanupKind = getCleanupKind(dtorKind);
1681  pushDestroy(cleanupKind, addr, type, getDestroyer(dtorKind),
1682  cleanupKind & EHCleanup);
1683 }
1684 
1686  QualType type, Destroyer *destroyer,
1687  bool useEHCleanupForArray) {
1688  pushFullExprCleanup<DestroyObject>(cleanupKind, addr, type,
1689  destroyer, useEHCleanupForArray);
1690 }
1691 
1693  EHStack.pushCleanup<CallStackRestore>(Kind, SPMem);
1694 }
1695 
1697  CleanupKind cleanupKind, Address addr, QualType type,
1698  Destroyer *destroyer, bool useEHCleanupForArray) {
1699  // Push an EH-only cleanup for the object now.
1700  // FIXME: When popping normal cleanups, we need to keep this EH cleanup
1701  // around in case a temporary's destructor throws an exception.
1702  if (cleanupKind & EHCleanup)
1703  EHStack.pushCleanup<DestroyObject>(
1704  static_cast<CleanupKind>(cleanupKind & ~NormalCleanup), addr, type,
1705  destroyer, useEHCleanupForArray);
1706 
1707  // Remember that we need to push a full cleanup for the object at the
1708  // end of the full-expression.
1709  pushCleanupAfterFullExpr<DestroyObject>(
1710  cleanupKind, addr, type, destroyer, useEHCleanupForArray);
1711 }
1712 
1713 /// emitDestroy - Immediately perform the destruction of the given
1714 /// object.
1715 ///
1716 /// \param addr - the address of the object; a type*
1717 /// \param type - the type of the object; if an array type, all
1718 /// objects are destroyed in reverse order
1719 /// \param destroyer - the function to call to destroy individual
1720 /// elements
1721 /// \param useEHCleanupForArray - whether an EH cleanup should be
1722 /// used when destroying array elements, in case one of the
1723 /// destructions throws an exception
1725  Destroyer *destroyer,
1726  bool useEHCleanupForArray) {
1727  const ArrayType *arrayType = getContext().getAsArrayType(type);
1728  if (!arrayType)
1729  return destroyer(*this, addr, type);
1730 
1731  llvm::Value *length = emitArrayLength(arrayType, type, addr);
1732 
1733  CharUnits elementAlign =
1734  addr.getAlignment()
1735  .alignmentOfArrayElement(getContext().getTypeSizeInChars(type));
1736 
1737  // Normally we have to check whether the array is zero-length.
1738  bool checkZeroLength = true;
1739 
1740  // But if the array length is constant, we can suppress that.
1741  if (llvm::ConstantInt *constLength = dyn_cast<llvm::ConstantInt>(length)) {
1742  // ...and if it's constant zero, we can just skip the entire thing.
1743  if (constLength->isZero()) return;
1744  checkZeroLength = false;
1745  }
1746 
1747  llvm::Value *begin = addr.getPointer();
1748  llvm::Value *end = Builder.CreateInBoundsGEP(begin, length);
1749  emitArrayDestroy(begin, end, type, elementAlign, destroyer,
1750  checkZeroLength, useEHCleanupForArray);
1751 }
1752 
1753 /// emitArrayDestroy - Destroys all the elements of the given array,
1754 /// beginning from last to first. The array cannot be zero-length.
1755 ///
1756 /// \param begin - a type* denoting the first element of the array
1757 /// \param end - a type* denoting one past the end of the array
1758 /// \param elementType - the element type of the array
1759 /// \param destroyer - the function to call to destroy elements
1760 /// \param useEHCleanup - whether to push an EH cleanup to destroy
1761 /// the remaining elements in case the destruction of a single
1762 /// element throws
1764  llvm::Value *end,
1765  QualType elementType,
1766  CharUnits elementAlign,
1767  Destroyer *destroyer,
1768  bool checkZeroLength,
1769  bool useEHCleanup) {
1770  assert(!elementType->isArrayType());
1771 
1772  // The basic structure here is a do-while loop, because we don't
1773  // need to check for the zero-element case.
1774  llvm::BasicBlock *bodyBB = createBasicBlock("arraydestroy.body");
1775  llvm::BasicBlock *doneBB = createBasicBlock("arraydestroy.done");
1776 
1777  if (checkZeroLength) {
1778  llvm::Value *isEmpty = Builder.CreateICmpEQ(begin, end,
1779  "arraydestroy.isempty");
1780  Builder.CreateCondBr(isEmpty, doneBB, bodyBB);
1781  }
1782 
1783  // Enter the loop body, making that address the current address.
1784  llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
1785  EmitBlock(bodyBB);
1786  llvm::PHINode *elementPast =
1787  Builder.CreatePHI(begin->getType(), 2, "arraydestroy.elementPast");
1788  elementPast->addIncoming(end, entryBB);
1789 
1790  // Shift the address back by one element.
1791  llvm::Value *negativeOne = llvm::ConstantInt::get(SizeTy, -1, true);
1792  llvm::Value *element = Builder.CreateInBoundsGEP(elementPast, negativeOne,
1793  "arraydestroy.element");
1794 
1795  if (useEHCleanup)
1796  pushRegularPartialArrayCleanup(begin, element, elementType, elementAlign,
1797  destroyer);
1798 
1799  // Perform the actual destruction there.
1800  destroyer(*this, Address(element, elementAlign), elementType);
1801 
1802  if (useEHCleanup)
1803  PopCleanupBlock();
1804 
1805  // Check whether we've reached the end.
1806  llvm::Value *done = Builder.CreateICmpEQ(element, begin, "arraydestroy.done");
1807  Builder.CreateCondBr(done, doneBB, bodyBB);
1808  elementPast->addIncoming(element, Builder.GetInsertBlock());
1809 
1810  // Done.
1811  EmitBlock(doneBB);
1812 }
1813 
1814 /// Perform partial array destruction as if in an EH cleanup. Unlike
1815 /// emitArrayDestroy, the element type here may still be an array type.
1817  llvm::Value *begin, llvm::Value *end,
1818  QualType type, CharUnits elementAlign,
1819  CodeGenFunction::Destroyer *destroyer) {
1820  // If the element type is itself an array, drill down.
1821  unsigned arrayDepth = 0;
1822  while (const ArrayType *arrayType = CGF.getContext().getAsArrayType(type)) {
1823  // VLAs don't require a GEP index to walk into.
1824  if (!isa<VariableArrayType>(arrayType))
1825  arrayDepth++;
1826  type = arrayType->getElementType();
1827  }
1828 
1829  if (arrayDepth) {
1830  llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
1831 
1832  SmallVector<llvm::Value*,4> gepIndices(arrayDepth+1, zero);
1833  begin = CGF.Builder.CreateInBoundsGEP(begin, gepIndices, "pad.arraybegin");
1834  end = CGF.Builder.CreateInBoundsGEP(end, gepIndices, "pad.arrayend");
1835  }
1836 
1837  // Destroy the array. We don't ever need an EH cleanup because we
1838  // assume that we're in an EH cleanup ourselves, so a throwing
1839  // destructor causes an immediate terminate.
1840  CGF.emitArrayDestroy(begin, end, type, elementAlign, destroyer,
1841  /*checkZeroLength*/ true, /*useEHCleanup*/ false);
1842 }
1843 
1844 namespace {
1845  /// RegularPartialArrayDestroy - a cleanup which performs a partial
1846  /// array destroy where the end pointer is regularly determined and
1847  /// does not need to be loaded from a local.
1848  class RegularPartialArrayDestroy final : public EHScopeStack::Cleanup {
1849  llvm::Value *ArrayBegin;
1850  llvm::Value *ArrayEnd;
1851  QualType ElementType;
1853  CharUnits ElementAlign;
1854  public:
1855  RegularPartialArrayDestroy(llvm::Value *arrayBegin, llvm::Value *arrayEnd,
1856  QualType elementType, CharUnits elementAlign,
1857  CodeGenFunction::Destroyer *destroyer)
1858  : ArrayBegin(arrayBegin), ArrayEnd(arrayEnd),
1859  ElementType(elementType), Destroyer(destroyer),
1860  ElementAlign(elementAlign) {}
1861 
1862  void Emit(CodeGenFunction &CGF, Flags flags) override {
1863  emitPartialArrayDestroy(CGF, ArrayBegin, ArrayEnd,
1864  ElementType, ElementAlign, Destroyer);
1865  }
1866  };
1867 
1868  /// IrregularPartialArrayDestroy - a cleanup which performs a
1869  /// partial array destroy where the end pointer is irregularly
1870  /// determined and must be loaded from a local.
1871  class IrregularPartialArrayDestroy final : public EHScopeStack::Cleanup {
1872  llvm::Value *ArrayBegin;
1873  Address ArrayEndPointer;
1874  QualType ElementType;
1876  CharUnits ElementAlign;
1877  public:
1878  IrregularPartialArrayDestroy(llvm::Value *arrayBegin,
1879  Address arrayEndPointer,
1880  QualType elementType,
1881  CharUnits elementAlign,
1882  CodeGenFunction::Destroyer *destroyer)
1883  : ArrayBegin(arrayBegin), ArrayEndPointer(arrayEndPointer),
1884  ElementType(elementType), Destroyer(destroyer),
1885  ElementAlign(elementAlign) {}
1886 
1887  void Emit(CodeGenFunction &CGF, Flags flags) override {
1888  llvm::Value *arrayEnd = CGF.Builder.CreateLoad(ArrayEndPointer);
1889  emitPartialArrayDestroy(CGF, ArrayBegin, arrayEnd,
1890  ElementType, ElementAlign, Destroyer);
1891  }
1892  };
1893 } // end anonymous namespace
1894 
1895 /// pushIrregularPartialArrayCleanup - Push an EH cleanup to destroy
1896 /// already-constructed elements of the given array. The cleanup
1897 /// may be popped with DeactivateCleanupBlock or PopCleanupBlock.
1898 ///
1899 /// \param elementType - the immediate element type of the array;
1900 /// possibly still an array type
1902  Address arrayEndPointer,
1903  QualType elementType,
1904  CharUnits elementAlign,
1905  Destroyer *destroyer) {
1906  pushFullExprCleanup<IrregularPartialArrayDestroy>(EHCleanup,
1907  arrayBegin, arrayEndPointer,
1908  elementType, elementAlign,
1909  destroyer);
1910 }
1911 
1912 /// pushRegularPartialArrayCleanup - Push an EH cleanup to destroy
1913 /// already-constructed elements of the given array. The cleanup
1914 /// may be popped with DeactivateCleanupBlock or PopCleanupBlock.
1915 ///
1916 /// \param elementType - the immediate element type of the array;
1917 /// possibly still an array type
1919  llvm::Value *arrayEnd,
1920  QualType elementType,
1921  CharUnits elementAlign,
1922  Destroyer *destroyer) {
1923  pushFullExprCleanup<RegularPartialArrayDestroy>(EHCleanup,
1924  arrayBegin, arrayEnd,
1925  elementType, elementAlign,
1926  destroyer);
1927 }
1928 
1929 /// Lazily declare the @llvm.lifetime.start intrinsic.
1931  if (LifetimeStartFn)
1932  return LifetimeStartFn;
1933  LifetimeStartFn = llvm::Intrinsic::getDeclaration(&getModule(),
1934  llvm::Intrinsic::lifetime_start, AllocaInt8PtrTy);
1935  return LifetimeStartFn;
1936 }
1937 
1938 /// Lazily declare the @llvm.lifetime.end intrinsic.
1940  if (LifetimeEndFn)
1941  return LifetimeEndFn;
1942  LifetimeEndFn = llvm::Intrinsic::getDeclaration(&getModule(),
1943  llvm::Intrinsic::lifetime_end, AllocaInt8PtrTy);
1944  return LifetimeEndFn;
1945 }
1946 
1947 namespace {
1948  /// A cleanup to perform a release of an object at the end of a
1949  /// function. This is used to balance out the incoming +1 of a
1950  /// ns_consumed argument when we can't reasonably do that just by
1951  /// not doing the initial retain for a __block argument.
1952  struct ConsumeARCParameter final : EHScopeStack::Cleanup {
1953  ConsumeARCParameter(llvm::Value *param,
1954  ARCPreciseLifetime_t precise)
1955  : Param(param), Precise(precise) {}
1956 
1957  llvm::Value *Param;
1958  ARCPreciseLifetime_t Precise;
1959 
1960  void Emit(CodeGenFunction &CGF, Flags flags) override {
1961  CGF.EmitARCRelease(Param, Precise);
1962  }
1963  };
1964 } // end anonymous namespace
1965 
1966 /// Emit an alloca (or GlobalValue depending on target)
1967 /// for the specified parameter and set up LocalDeclMap.
1969  unsigned ArgNo) {
1970  // FIXME: Why isn't ImplicitParamDecl a ParmVarDecl?
1971  assert((isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D)) &&
1972  "Invalid argument to EmitParmDecl");
1973 
1974  Arg.getAnyValue()->setName(D.getName());
1975 
1976  QualType Ty = D.getType();
1977 
1978  // Use better IR generation for certain implicit parameters.
1979  if (auto IPD = dyn_cast<ImplicitParamDecl>(&D)) {
1980  // The only implicit argument a block has is its literal.
1981  // This may be passed as an inalloca'ed value on Windows x86.
1982  if (BlockInfo) {
1983  llvm::Value *V = Arg.isIndirect()
1985  : Arg.getDirectValue();
1986  setBlockContextParameter(IPD, ArgNo, V);
1987  return;
1988  }
1989  }
1990 
1991  Address DeclPtr = Address::invalid();
1992  bool DoStore = false;
1993  bool IsScalar = hasScalarEvaluationKind(Ty);
1994  // If we already have a pointer to the argument, reuse the input pointer.
1995  if (Arg.isIndirect()) {
1996  DeclPtr = Arg.getIndirectAddress();
1997  // If we have a prettier pointer type at this point, bitcast to that.
1998  unsigned AS = DeclPtr.getType()->getAddressSpace();
1999  llvm::Type *IRTy = ConvertTypeForMem(Ty)->getPointerTo(AS);
2000  if (DeclPtr.getType() != IRTy)
2001  DeclPtr = Builder.CreateBitCast(DeclPtr, IRTy, D.getName());
2002  // Indirect argument is in alloca address space, which may be different
2003  // from the default address space.
2004  auto AllocaAS = CGM.getASTAllocaAddressSpace();
2005  auto *V = DeclPtr.getPointer();
2006  auto SrcLangAS = getLangOpts().OpenCL ? LangAS::opencl_private : AllocaAS;
2007  auto DestLangAS =
2009  if (SrcLangAS != DestLangAS) {
2010  assert(getContext().getTargetAddressSpace(SrcLangAS) ==
2011  CGM.getDataLayout().getAllocaAddrSpace());
2012  auto DestAS = getContext().getTargetAddressSpace(DestLangAS);
2013  auto *T = V->getType()->getPointerElementType()->getPointerTo(DestAS);
2014  DeclPtr = Address(getTargetHooks().performAddrSpaceCast(
2015  *this, V, SrcLangAS, DestLangAS, T, true),
2016  DeclPtr.getAlignment());
2017  }
2018 
2019  // Push a destructor cleanup for this parameter if the ABI requires it.
2020  // Don't push a cleanup in a thunk for a method that will also emit a
2021  // cleanup.
2023  Ty->getAs<RecordType>()->getDecl()->isParamDestroyedInCallee()) {
2024  if (QualType::DestructionKind DtorKind = Ty.isDestructedType()) {
2025  assert((DtorKind == QualType::DK_cxx_destructor ||
2026  DtorKind == QualType::DK_nontrivial_c_struct) &&
2027  "unexpected destructor type");
2028  pushDestroy(DtorKind, DeclPtr, Ty);
2029  CalleeDestructedParamCleanups[cast<ParmVarDecl>(&D)] =
2031  }
2032  }
2033  } else {
2034  // Check if the parameter address is controlled by OpenMP runtime.
2035  Address OpenMPLocalAddr =
2036  getLangOpts().OpenMP
2037  ? CGM.getOpenMPRuntime().getAddressOfLocalVariable(*this, &D)
2038  : Address::invalid();
2039  if (getLangOpts().OpenMP && OpenMPLocalAddr.isValid()) {
2040  DeclPtr = OpenMPLocalAddr;
2041  } else {
2042  // Otherwise, create a temporary to hold the value.
2043  DeclPtr = CreateMemTemp(Ty, getContext().getDeclAlign(&D),
2044  D.getName() + ".addr");
2045  }
2046  DoStore = true;
2047  }
2048 
2049  llvm::Value *ArgVal = (DoStore ? Arg.getDirectValue() : nullptr);
2050 
2051  LValue lv = MakeAddrLValue(DeclPtr, Ty);
2052  if (IsScalar) {
2053  Qualifiers qs = Ty.getQualifiers();
2054  if (Qualifiers::ObjCLifetime lt = qs.getObjCLifetime()) {
2055  // We honor __attribute__((ns_consumed)) for types with lifetime.
2056  // For __strong, it's handled by just skipping the initial retain;
2057  // otherwise we have to balance out the initial +1 with an extra
2058  // cleanup to do the release at the end of the function.
2059  bool isConsumed = D.hasAttr<NSConsumedAttr>();
2060 
2061  // 'self' is always formally __strong, but if this is not an
2062  // init method then we don't want to retain it.
2063  if (D.isARCPseudoStrong()) {
2064  const ObjCMethodDecl *method = cast<ObjCMethodDecl>(CurCodeDecl);
2065  assert(&D == method->getSelfDecl());
2066  assert(lt == Qualifiers::OCL_Strong);
2067  assert(qs.hasConst());
2068  assert(method->getMethodFamily() != OMF_init);
2069  (void) method;
2071  }
2072 
2073  // Load objects passed indirectly.
2074  if (Arg.isIndirect() && !ArgVal)
2075  ArgVal = Builder.CreateLoad(DeclPtr);
2076 
2077  if (lt == Qualifiers::OCL_Strong) {
2078  if (!isConsumed) {
2079  if (CGM.getCodeGenOpts().OptimizationLevel == 0) {
2080  // use objc_storeStrong(&dest, value) for retaining the
2081  // object. But first, store a null into 'dest' because
2082  // objc_storeStrong attempts to release its old value.
2083  llvm::Value *Null = CGM.EmitNullConstant(D.getType());
2084  EmitStoreOfScalar(Null, lv, /* isInitialization */ true);
2085  EmitARCStoreStrongCall(lv.getAddress(), ArgVal, true);
2086  DoStore = false;
2087  }
2088  else
2089  // Don't use objc_retainBlock for block pointers, because we
2090  // don't want to Block_copy something just because we got it
2091  // as a parameter.
2092  ArgVal = EmitARCRetainNonBlock(ArgVal);
2093  }
2094  } else {
2095  // Push the cleanup for a consumed parameter.
2096  if (isConsumed) {
2097  ARCPreciseLifetime_t precise = (D.hasAttr<ObjCPreciseLifetimeAttr>()
2099  EHStack.pushCleanup<ConsumeARCParameter>(getARCCleanupKind(), ArgVal,
2100  precise);
2101  }
2102 
2103  if (lt == Qualifiers::OCL_Weak) {
2104  EmitARCInitWeak(DeclPtr, ArgVal);
2105  DoStore = false; // The weak init is a store, no need to do two.
2106  }
2107  }
2108 
2109  // Enter the cleanup scope.
2110  EmitAutoVarWithLifetime(*this, D, DeclPtr, lt);
2111  }
2112  }
2113 
2114  // Store the initial value into the alloca.
2115  if (DoStore)
2116  EmitStoreOfScalar(ArgVal, lv, /* isInitialization */ true);
2117 
2118  setAddrOfLocalVar(&D, DeclPtr);
2119 
2120  // Emit debug info for param declaration.
2121  if (CGDebugInfo *DI = getDebugInfo()) {
2122  if (CGM.getCodeGenOpts().getDebugInfo() >=
2124  DI->EmitDeclareOfArgVariable(&D, DeclPtr.getPointer(), ArgNo, Builder);
2125  }
2126  }
2127 
2128  if (D.hasAttr<AnnotateAttr>())
2129  EmitVarAnnotations(&D, DeclPtr.getPointer());
2130 
2131  // We can only check return value nullability if all arguments to the
2132  // function satisfy their nullability preconditions. This makes it necessary
2133  // to emit null checks for args in the function body itself.
2134  if (requiresReturnValueNullabilityCheck()) {
2135  auto Nullability = Ty->getNullability(getContext());
2137  SanitizerScope SanScope(this);
2138  RetValNullabilityPrecondition =
2139  Builder.CreateAnd(RetValNullabilityPrecondition,
2140  Builder.CreateIsNotNull(Arg.getAnyValue()));
2141  }
2142  }
2143 }
2144 
2146  CodeGenFunction *CGF) {
2147  if (!LangOpts.OpenMP || (!LangOpts.EmitAllDecls && !D->isUsed()))
2148  return;
2149  getOpenMPRuntime().emitUserDefinedReduction(CGF, D);
2150 }
2151 
2153  //Do nothing - here to avoid build errors
2154 }
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:853
void setImplicit(bool I=true)
Definition: DeclBase.h:548
Represents a function declaration or definition.
Definition: Decl.h:1732
void EmitStaticVarDecl(const VarDecl &D, llvm::GlobalValue::LinkageTypes Linkage)
Definition: CGDecl.cpp:378
llvm::Value * EmitARCRetainAutoreleaseScalarExpr(const Expr *expr)
Definition: CGObjC.cpp:2982
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
Definition: CGDecl.cpp:1649
A (possibly-)qualified type.
Definition: Type.h:642
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:3192
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2093
bool isArrayType() const
Definition: Type.h:6319
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:2694
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:6343
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:1534
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
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:2906
void EmitAutoVarDecl(const VarDecl &D)
EmitAutoVarDecl - Emit an auto variable declaration.
Definition: CGDecl.cpp:1029
static Destroyer destroyARCStrongPrecise
void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
Definition: CGDecl.cpp:1696
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:1898
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:891
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2808
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1262
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
Definition: EHScopeStack.h:379
void EmitARCCopyWeak(Address dst, Address src)
void @objc_copyWeak(i8** dest, i8** src) Disregards the current value in dest.
Definition: CGObjC.cpp:2306
constexpr XRayInstrMask Function
Definition: XRayInstr.h:39
llvm::Value * EmitARCRetainNonBlock(llvm::Value *value)
Retain the given object, with normal retain semantics.
Definition: CGObjC.cpp:1965
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2478
The type is a struct containing a field whose type is not PCK_Trivial.
Definition: Type.h:1096
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:937
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:958
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:3787
Represents a variable declaration or definition.
Definition: Decl.h:812
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:6683
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
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
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.
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
Definition: ExprCXX.h:3033
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:1356
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:1724
void emitByrefStructureInit(const AutoVarEmission &emission)
Initialize the structural components of a __block variable, i.e.
Definition: CGBlocks.cpp:2819
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:1490
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
Definition: CGExpr.cpp:589
Qualifiers::ObjCLifetime getObjCLifetime() const
Definition: CGValue.h:266
bool isReferenceType() const
Definition: Type.h:6282
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:1666
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Definition: EHScopeStack.h:81
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:565
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:1930
ObjCMethodFamily getMethodFamily() const
Determines the family of this method.
Definition: DeclObjC.cpp:986
llvm::Value * EmitARCStoreStrongCall(Address addr, llvm::Value *value, bool resultIgnored)
Store into a strong object.
Definition: CGObjC.cpp:2118
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:1918
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:2152
void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D, CodeGenFunction *CGF=nullptr)
Emit a code for declare reduction construct.
Definition: CGDecl.cpp:2145
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:404
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:229
static void emitStoresForConstant(CodeGenModule &CGM, const VarDecl &D, Address Loc, bool isVolatile, CGBuilderTy &Builder, llvm::Constant *constant)
Definition: CGDecl.cpp:966
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:3093
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:274
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1383
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:2545
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:40
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:2966
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:1337
void registerVLASizeExpression(QualType Ty, llvm::Metadata *SizeExpr)
Register VLA size expression debug node with the qualified type.
Definition: CGDebugInfo.h:342
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:1080
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:613
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:1120
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1605
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:2250
void EmitCXXGuardedInit(const VarDecl &D, llvm::GlobalVariable *DeclPtr, bool PerformInit)
Emit code in this function to perform a guarded variable initialization.
Definition: CGDeclCXX.cpp:256
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:3850
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:636
This represents one expression.
Definition: Expr.h:105
void EmitARCMoveWeak(Address dst, Address src)
void @objc_moveWeak(i8** dest, i8** src) Disregards the current value in dest.
Definition: CGObjC.cpp:2297
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:1400
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:1035
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:4979
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2700
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:1306
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:330
DeclContext * getDeclContext()
Definition: DeclBase.h:427
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:127
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:1763
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
Definition: Type.h:6641
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
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:406
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:1479
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:1676
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:1064
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:644
void EmitARCRelease(llvm::Value *value, ARCPreciseLifetime_t precise)
Release the given object.
Definition: CGObjC.cpp:2072
LValue EmitDeclRefLValue(const DeclRefExpr *E)
Definition: CGExpr.cpp:2427
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:6162
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:2094
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:291
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:1816
const Decl * getDecl() const
Definition: GlobalDecl.h:64
const BlockByrefInfo & getBlockByrefInfo(const VarDecl *var)
BuildByrefInfo - This routine changes a __block variable declared as T x into:
Definition: CGBlocks.cpp:2731
llvm::Value * EmitLifetimeStart(uint64_t Size, llvm::Value *Addr)
Emit a lifetime.begin marker if some criteria are satisfied.
Definition: CGDecl.cpp:1038
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:1806
static bool isAccessedBy(const VarDecl &var, const Stmt *s)
Definition: CGDecl.cpp:631
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:1386
bool isObjCObjectPointerType() const
Definition: Type.h:6367
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:1160
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:2940
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:1968
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:3616
QualType getType() const
Definition: CGValue.h:264
llvm::Constant * getLLVMLifetimeEndFn()
Lazily declare the .lifetime.end intrinsic.
Definition: CGDecl.cpp:1939
void enterFullExpression(const ExprWithCleanups *E)
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:216
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:1056
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2908
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:715
void EmitCXXDestructorCall(const CXXDestructorDecl *D, CXXDtorType Type, bool ForVirtualBase, bool Delegating, Address This)
Definition: CGClass.cpp:2376
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1261
ArrayRef< Capture > captures() const
Definition: Decl.h:3977
const CGFunctionInfo & arrangeFunctionDeclaration(const FunctionDecl *FD)
Free functions are functions that are compatible with an ordinary C function pointer type...
Definition: CGCall.cpp:431
QualType getUnderlyingType() const
Definition: Decl.h:2963
const Expr * getInit() const
Definition: Decl.h:1219
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:1002
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:1773
static bool hasAggregateEvaluationKind(QualType T)
void EmitAutoVarCleanups(const AutoVarEmission &emission)
Definition: CGDecl.cpp:1601
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4346
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:2013
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:2833
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:6380
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:445
void EmitARCInitWeak(Address addr, llvm::Value *value)
i8* @objc_initWeak(i8** addr, i8* value) Returns value.
Definition: CGObjC.cpp:2262
Optional< NullabilityKind > getNullability(const ASTContext &context) const
Determine the nullability of the given type.
Definition: Type.cpp:3667
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.
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1134
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:6126
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:1324
llvm::Type * ConvertType(QualType T)
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6073
LValue EmitLValue(const Expr *E)
EmitLValue - Emit code to compute a designator that specifies the location of the expression...
Definition: CGExpr.cpp:1232
Address ReturnValue
ReturnValue - The temporary alloca to hold the return value.
bool isSamplerT() const
Definition: Type.h:6424
void pushStackRestore(CleanupKind kind, Address SPMem)
Definition: CGDecl.cpp:1692
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:1068
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:275
void setLocation(SourceLocation Loc)
Update the current source location.
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:976
static RValue get(llvm::Value *V)
Definition: CGValue.h:86
void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr)
Definition: CGDecl.cpp:1054
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:2775
bool isLocalVarDecl() const
Returns true for local variable declarations other than parameters.
Definition: Decl.h:1104
QualType getType() const
Definition: Decl.h:647
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.
Automatic storage duration (most local variables).
Definition: Specifiers.h:278
SanitizerMetadata * getSanitizerMetadata()
bool isConstant(const ASTContext &Ctx) const
Definition: Type.h:777
bool CurFuncIsThunk
In C++, whether we are code generating a thunk.
const LangOptions & getLangOpts() const
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.h:2505
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
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:2694
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:1901
bool isExternallyVisible() const
Definition: Decl.h:379
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:2514
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:1066