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