clang  10.0.0svn
CGExprAgg.cpp
Go to the documentation of this file.
1 //===--- CGExprAgg.cpp - Emit LLVM Code from Aggregate Expressions --------===//
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 Aggregate Expr nodes as LLVM code.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "CodeGenFunction.h"
14 #include "CGCXXABI.h"
15 #include "CGObjCRuntime.h"
16 #include "CodeGenModule.h"
17 #include "ConstantEmitter.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/DeclTemplate.h"
21 #include "clang/AST/StmtVisitor.h"
22 #include "llvm/IR/Constants.h"
23 #include "llvm/IR/Function.h"
24 #include "llvm/IR/GlobalVariable.h"
25 #include "llvm/IR/Intrinsics.h"
26 #include "llvm/IR/IntrinsicInst.h"
27 using namespace clang;
28 using namespace CodeGen;
29 
30 //===----------------------------------------------------------------------===//
31 // Aggregate Expression Emitter
32 //===----------------------------------------------------------------------===//
33 
34 namespace {
35 class AggExprEmitter : public StmtVisitor<AggExprEmitter> {
36  CodeGenFunction &CGF;
37  CGBuilderTy &Builder;
38  AggValueSlot Dest;
39  bool IsResultUnused;
40 
41  AggValueSlot EnsureSlot(QualType T) {
42  if (!Dest.isIgnored()) return Dest;
43  return CGF.CreateAggTemp(T, "agg.tmp.ensured");
44  }
45  void EnsureDest(QualType T) {
46  if (!Dest.isIgnored()) return;
47  Dest = CGF.CreateAggTemp(T, "agg.tmp.ensured");
48  }
49 
50  // Calls `Fn` with a valid return value slot, potentially creating a temporary
51  // to do so. If a temporary is created, an appropriate copy into `Dest` will
52  // be emitted, as will lifetime markers.
53  //
54  // The given function should take a ReturnValueSlot, and return an RValue that
55  // points to said slot.
56  void withReturnValueSlot(const Expr *E,
57  llvm::function_ref<RValue(ReturnValueSlot)> Fn);
58 
59 public:
60  AggExprEmitter(CodeGenFunction &cgf, AggValueSlot Dest, bool IsResultUnused)
61  : CGF(cgf), Builder(CGF.Builder), Dest(Dest),
62  IsResultUnused(IsResultUnused) { }
63 
64  //===--------------------------------------------------------------------===//
65  // Utilities
66  //===--------------------------------------------------------------------===//
67 
68  /// EmitAggLoadOfLValue - Given an expression with aggregate type that
69  /// represents a value lvalue, this method emits the address of the lvalue,
70  /// then loads the result into DestPtr.
71  void EmitAggLoadOfLValue(const Expr *E);
72 
73  enum ExprValueKind {
74  EVK_RValue,
75  EVK_NonRValue
76  };
77 
78  /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
79  /// SrcIsRValue is true if source comes from an RValue.
80  void EmitFinalDestCopy(QualType type, const LValue &src,
81  ExprValueKind SrcValueKind = EVK_NonRValue);
82  void EmitFinalDestCopy(QualType type, RValue src);
83  void EmitCopy(QualType type, const AggValueSlot &dest,
84  const AggValueSlot &src);
85 
86  void EmitMoveFromReturnSlot(const Expr *E, RValue Src);
87 
88  void EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,
89  QualType ArrayQTy, InitListExpr *E);
90 
92  if (CGF.getLangOpts().getGC() && TypeRequiresGCollection(T))
95  }
96 
97  bool TypeRequiresGCollection(QualType T);
98 
99  //===--------------------------------------------------------------------===//
100  // Visitor Methods
101  //===--------------------------------------------------------------------===//
102 
103  void Visit(Expr *E) {
104  ApplyDebugLocation DL(CGF, E);
106  }
107 
108  void VisitStmt(Stmt *S) {
109  CGF.ErrorUnsupported(S, "aggregate expression");
110  }
111  void VisitParenExpr(ParenExpr *PE) { Visit(PE->getSubExpr()); }
112  void VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
113  Visit(GE->getResultExpr());
114  }
115  void VisitCoawaitExpr(CoawaitExpr *E) {
116  CGF.EmitCoawaitExpr(*E, Dest, IsResultUnused);
117  }
118  void VisitCoyieldExpr(CoyieldExpr *E) {
119  CGF.EmitCoyieldExpr(*E, Dest, IsResultUnused);
120  }
121  void VisitUnaryCoawait(UnaryOperator *E) { Visit(E->getSubExpr()); }
122  void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
123  void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
124  return Visit(E->getReplacement());
125  }
126 
127  void VisitConstantExpr(ConstantExpr *E) {
128  return Visit(E->getSubExpr());
129  }
130 
131  // l-values.
132  void VisitDeclRefExpr(DeclRefExpr *E) { EmitAggLoadOfLValue(E); }
133  void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }
134  void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
135  void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }
136  void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
137  void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
138  EmitAggLoadOfLValue(E);
139  }
140  void VisitPredefinedExpr(const PredefinedExpr *E) {
141  EmitAggLoadOfLValue(E);
142  }
143 
144  // Operators.
145  void VisitCastExpr(CastExpr *E);
146  void VisitCallExpr(const CallExpr *E);
147  void VisitStmtExpr(const StmtExpr *E);
148  void VisitBinaryOperator(const BinaryOperator *BO);
149  void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO);
150  void VisitBinAssign(const BinaryOperator *E);
151  void VisitBinComma(const BinaryOperator *E);
152  void VisitBinCmp(const BinaryOperator *E);
153  void VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) {
154  Visit(E->getSemanticForm());
155  }
156 
157  void VisitObjCMessageExpr(ObjCMessageExpr *E);
158  void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
159  EmitAggLoadOfLValue(E);
160  }
161 
162  void VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E);
163  void VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
164  void VisitChooseExpr(const ChooseExpr *CE);
165  void VisitInitListExpr(InitListExpr *E);
166  void VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E,
167  llvm::Value *outerBegin = nullptr);
168  void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
169  void VisitNoInitExpr(NoInitExpr *E) { } // Do nothing.
170  void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
172  Visit(DAE->getExpr());
173  }
174  void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
176  Visit(DIE->getExpr());
177  }
178  void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
179  void VisitCXXConstructExpr(const CXXConstructExpr *E);
180  void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
181  void VisitLambdaExpr(LambdaExpr *E);
182  void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
183  void VisitExprWithCleanups(ExprWithCleanups *E);
184  void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
185  void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); }
186  void VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
187  void VisitOpaqueValueExpr(OpaqueValueExpr *E);
188 
189  void VisitPseudoObjectExpr(PseudoObjectExpr *E) {
190  if (E->isGLValue()) {
191  LValue LV = CGF.EmitPseudoObjectLValue(E);
192  return EmitFinalDestCopy(E->getType(), LV);
193  }
194 
195  CGF.EmitPseudoObjectRValue(E, EnsureSlot(E->getType()));
196  }
197 
198  void VisitVAArgExpr(VAArgExpr *E);
199 
200  void EmitInitializationToLValue(Expr *E, LValue Address);
201  void EmitNullInitializationToLValue(LValue Address);
202  // case Expr::ChooseExprClass:
203  void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
204  void VisitAtomicExpr(AtomicExpr *E) {
205  RValue Res = CGF.EmitAtomicExpr(E);
206  EmitFinalDestCopy(E->getType(), Res);
207  }
208 };
209 } // end anonymous namespace.
210 
211 //===----------------------------------------------------------------------===//
212 // Utilities
213 //===----------------------------------------------------------------------===//
214 
215 /// EmitAggLoadOfLValue - Given an expression with aggregate type that
216 /// represents a value lvalue, this method emits the address of the lvalue,
217 /// then loads the result into DestPtr.
218 void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
219  LValue LV = CGF.EmitLValue(E);
220 
221  // If the type of the l-value is atomic, then do an atomic load.
222  if (LV.getType()->isAtomicType() || CGF.LValueIsSuitableForInlineAtomic(LV)) {
223  CGF.EmitAtomicLoad(LV, E->getExprLoc(), Dest);
224  return;
225  }
226 
227  EmitFinalDestCopy(E->getType(), LV);
228 }
229 
230 /// True if the given aggregate type requires special GC API calls.
231 bool AggExprEmitter::TypeRequiresGCollection(QualType T) {
232  // Only record types have members that might require garbage collection.
233  const RecordType *RecordTy = T->getAs<RecordType>();
234  if (!RecordTy) return false;
235 
236  // Don't mess with non-trivial C++ types.
237  RecordDecl *Record = RecordTy->getDecl();
238  if (isa<CXXRecordDecl>(Record) &&
239  (cast<CXXRecordDecl>(Record)->hasNonTrivialCopyConstructor() ||
240  !cast<CXXRecordDecl>(Record)->hasTrivialDestructor()))
241  return false;
242 
243  // Check whether the type has an object member.
244  return Record->hasObjectMember();
245 }
246 
247 void AggExprEmitter::withReturnValueSlot(
248  const Expr *E, llvm::function_ref<RValue(ReturnValueSlot)> EmitCall) {
249  QualType RetTy = E->getType();
250  bool RequiresDestruction =
251  Dest.isIgnored() &&
253 
254  // If it makes no observable difference, save a memcpy + temporary.
255  //
256  // We need to always provide our own temporary if destruction is required.
257  // Otherwise, EmitCall will emit its own, notice that it's "unused", and end
258  // its lifetime before we have the chance to emit a proper destructor call.
259  bool UseTemp = Dest.isPotentiallyAliased() || Dest.requiresGCollection() ||
260  (RequiresDestruction && !Dest.getAddress().isValid());
261 
262  Address RetAddr = Address::invalid();
263  Address RetAllocaAddr = Address::invalid();
264 
265  EHScopeStack::stable_iterator LifetimeEndBlock;
266  llvm::Value *LifetimeSizePtr = nullptr;
267  llvm::IntrinsicInst *LifetimeStartInst = nullptr;
268  if (!UseTemp) {
269  RetAddr = Dest.getAddress();
270  } else {
271  RetAddr = CGF.CreateMemTemp(RetTy, "tmp", &RetAllocaAddr);
272  uint64_t Size =
273  CGF.CGM.getDataLayout().getTypeAllocSize(CGF.ConvertTypeForMem(RetTy));
274  LifetimeSizePtr = CGF.EmitLifetimeStart(Size, RetAllocaAddr.getPointer());
275  if (LifetimeSizePtr) {
276  LifetimeStartInst =
277  cast<llvm::IntrinsicInst>(std::prev(Builder.GetInsertPoint()));
278  assert(LifetimeStartInst->getIntrinsicID() ==
279  llvm::Intrinsic::lifetime_start &&
280  "Last insertion wasn't a lifetime.start?");
281 
283  NormalEHLifetimeMarker, RetAllocaAddr, LifetimeSizePtr);
284  LifetimeEndBlock = CGF.EHStack.stable_begin();
285  }
286  }
287 
288  RValue Src =
289  EmitCall(ReturnValueSlot(RetAddr, Dest.isVolatile(), IsResultUnused));
290 
291  if (RequiresDestruction)
292  CGF.pushDestroy(RetTy.isDestructedType(), Src.getAggregateAddress(), RetTy);
293 
294  if (!UseTemp)
295  return;
296 
297  assert(Dest.getPointer() != Src.getAggregatePointer());
298  EmitFinalDestCopy(E->getType(), Src);
299 
300  if (!RequiresDestruction && LifetimeStartInst) {
301  // If there's no dtor to run, the copy was the last use of our temporary.
302  // Since we're not guaranteed to be in an ExprWithCleanups, clean up
303  // eagerly.
304  CGF.DeactivateCleanupBlock(LifetimeEndBlock, LifetimeStartInst);
305  CGF.EmitLifetimeEnd(LifetimeSizePtr, RetAllocaAddr.getPointer());
306  }
307 }
308 
309 /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
310 void AggExprEmitter::EmitFinalDestCopy(QualType type, RValue src) {
311  assert(src.isAggregate() && "value must be aggregate value!");
312  LValue srcLV = CGF.MakeAddrLValue(src.getAggregateAddress(), type);
313  EmitFinalDestCopy(type, srcLV, EVK_RValue);
314 }
315 
316 /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
317 void AggExprEmitter::EmitFinalDestCopy(QualType type, const LValue &src,
318  ExprValueKind SrcValueKind) {
319  // If Dest is ignored, then we're evaluating an aggregate expression
320  // in a context that doesn't care about the result. Note that loads
321  // from volatile l-values force the existence of a non-ignored
322  // destination.
323  if (Dest.isIgnored())
324  return;
325 
326  // Copy non-trivial C structs here.
327  LValue DstLV = CGF.MakeAddrLValue(
328  Dest.getAddress(), Dest.isVolatile() ? type.withVolatile() : type);
329 
330  if (SrcValueKind == EVK_RValue) {
332  if (Dest.isPotentiallyAliased())
333  CGF.callCStructMoveAssignmentOperator(DstLV, src);
334  else
335  CGF.callCStructMoveConstructor(DstLV, src);
336  return;
337  }
338  } else {
340  if (Dest.isPotentiallyAliased())
341  CGF.callCStructCopyAssignmentOperator(DstLV, src);
342  else
343  CGF.callCStructCopyConstructor(DstLV, src);
344  return;
345  }
346  }
347 
348  AggValueSlot srcAgg =
350  needsGC(type), AggValueSlot::IsAliased,
352  EmitCopy(type, Dest, srcAgg);
353 }
354 
355 /// Perform a copy from the source into the destination.
356 ///
357 /// \param type - the type of the aggregate being copied; qualifiers are
358 /// ignored
359 void AggExprEmitter::EmitCopy(QualType type, const AggValueSlot &dest,
360  const AggValueSlot &src) {
361  if (dest.requiresGCollection()) {
362  CharUnits sz = dest.getPreferredSize(CGF.getContext(), type);
363  llvm::Value *size = llvm::ConstantInt::get(CGF.SizeTy, sz.getQuantity());
365  dest.getAddress(),
366  src.getAddress(),
367  size);
368  return;
369  }
370 
371  // If the result of the assignment is used, copy the LHS there also.
372  // It's volatile if either side is. Use the minimum alignment of
373  // the two sides.
374  LValue DestLV = CGF.MakeAddrLValue(dest.getAddress(), type);
375  LValue SrcLV = CGF.MakeAddrLValue(src.getAddress(), type);
376  CGF.EmitAggregateCopy(DestLV, SrcLV, type, dest.mayOverlap(),
377  dest.isVolatile() || src.isVolatile());
378 }
379 
380 /// Emit the initializer for a std::initializer_list initialized with a
381 /// real initializer list.
382 void
383 AggExprEmitter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
384  // Emit an array containing the elements. The array is externally destructed
385  // if the std::initializer_list object is.
386  ASTContext &Ctx = CGF.getContext();
387  LValue Array = CGF.EmitLValue(E->getSubExpr());
388  assert(Array.isSimple() && "initializer_list array not a simple lvalue");
389  Address ArrayPtr = Array.getAddress();
390 
393  assert(ArrayType && "std::initializer_list constructed from non-array");
394 
395  // FIXME: Perform the checks on the field types in SemaInit.
396  RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
398  if (Field == Record->field_end()) {
399  CGF.ErrorUnsupported(E, "weird std::initializer_list");
400  return;
401  }
402 
403  // Start pointer.
404  if (!Field->getType()->isPointerType() ||
405  !Ctx.hasSameType(Field->getType()->getPointeeType(),
406  ArrayType->getElementType())) {
407  CGF.ErrorUnsupported(E, "weird std::initializer_list");
408  return;
409  }
410 
411  AggValueSlot Dest = EnsureSlot(E->getType());
412  LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
413  LValue Start = CGF.EmitLValueForFieldInitialization(DestLV, *Field);
414  llvm::Value *Zero = llvm::ConstantInt::get(CGF.PtrDiffTy, 0);
415  llvm::Value *IdxStart[] = { Zero, Zero };
416  llvm::Value *ArrayStart =
417  Builder.CreateInBoundsGEP(ArrayPtr.getPointer(), IdxStart, "arraystart");
418  CGF.EmitStoreThroughLValue(RValue::get(ArrayStart), Start);
419  ++Field;
420 
421  if (Field == Record->field_end()) {
422  CGF.ErrorUnsupported(E, "weird std::initializer_list");
423  return;
424  }
425 
426  llvm::Value *Size = Builder.getInt(ArrayType->getSize());
427  LValue EndOrLength = CGF.EmitLValueForFieldInitialization(DestLV, *Field);
428  if (Field->getType()->isPointerType() &&
429  Ctx.hasSameType(Field->getType()->getPointeeType(),
430  ArrayType->getElementType())) {
431  // End pointer.
432  llvm::Value *IdxEnd[] = { Zero, Size };
433  llvm::Value *ArrayEnd =
434  Builder.CreateInBoundsGEP(ArrayPtr.getPointer(), IdxEnd, "arrayend");
435  CGF.EmitStoreThroughLValue(RValue::get(ArrayEnd), EndOrLength);
436  } else if (Ctx.hasSameType(Field->getType(), Ctx.getSizeType())) {
437  // Length.
438  CGF.EmitStoreThroughLValue(RValue::get(Size), EndOrLength);
439  } else {
440  CGF.ErrorUnsupported(E, "weird std::initializer_list");
441  return;
442  }
443 }
444 
445 /// Determine if E is a trivial array filler, that is, one that is
446 /// equivalent to zero-initialization.
447 static bool isTrivialFiller(Expr *E) {
448  if (!E)
449  return true;
450 
451  if (isa<ImplicitValueInitExpr>(E))
452  return true;
453 
454  if (auto *ILE = dyn_cast<InitListExpr>(E)) {
455  if (ILE->getNumInits())
456  return false;
457  return isTrivialFiller(ILE->getArrayFiller());
458  }
459 
460  if (auto *Cons = dyn_cast_or_null<CXXConstructExpr>(E))
461  return Cons->getConstructor()->isDefaultConstructor() &&
462  Cons->getConstructor()->isTrivial();
463 
464  // FIXME: Are there other cases where we can avoid emitting an initializer?
465  return false;
466 }
467 
468 /// Emit initialization of an array from an initializer list.
469 void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,
470  QualType ArrayQTy, InitListExpr *E) {
471  uint64_t NumInitElements = E->getNumInits();
472 
473  uint64_t NumArrayElements = AType->getNumElements();
474  assert(NumInitElements <= NumArrayElements);
475 
476  QualType elementType =
477  CGF.getContext().getAsArrayType(ArrayQTy)->getElementType();
478 
479  // DestPtr is an array*. Construct an elementType* by drilling
480  // down a level.
481  llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
482  llvm::Value *indices[] = { zero, zero };
483  llvm::Value *begin =
484  Builder.CreateInBoundsGEP(DestPtr.getPointer(), indices, "arrayinit.begin");
485 
486  CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
487  CharUnits elementAlign =
488  DestPtr.getAlignment().alignmentOfArrayElement(elementSize);
489 
490  // Consider initializing the array by copying from a global. For this to be
491  // more efficient than per-element initialization, the size of the elements
492  // with explicit initializers should be large enough.
493  if (NumInitElements * elementSize.getQuantity() > 16 &&
494  elementType.isTriviallyCopyableType(CGF.getContext())) {
495  CodeGen::CodeGenModule &CGM = CGF.CGM;
497  LangAS AS = ArrayQTy.getAddressSpace();
498  if (llvm::Constant *C = Emitter.tryEmitForInitializer(E, AS, ArrayQTy)) {
499  auto GV = new llvm::GlobalVariable(
500  CGM.getModule(), C->getType(),
501  CGM.isTypeConstant(ArrayQTy, /* ExcludeCtorDtor= */ true),
502  llvm::GlobalValue::PrivateLinkage, C, "constinit",
503  /* InsertBefore= */ nullptr, llvm::GlobalVariable::NotThreadLocal,
505  Emitter.finalize(GV);
506  CharUnits Align = CGM.getContext().getTypeAlignInChars(ArrayQTy);
507  GV->setAlignment(Align.getAsAlign());
508  EmitFinalDestCopy(ArrayQTy, CGF.MakeAddrLValue(GV, ArrayQTy, Align));
509  return;
510  }
511  }
512 
513  // Exception safety requires us to destroy all the
514  // already-constructed members if an initializer throws.
515  // For that, we'll need an EH cleanup.
516  QualType::DestructionKind dtorKind = elementType.isDestructedType();
517  Address endOfInit = Address::invalid();
519  llvm::Instruction *cleanupDominator = nullptr;
520  if (CGF.needsEHCleanup(dtorKind)) {
521  // In principle we could tell the cleanup where we are more
522  // directly, but the control flow can get so varied here that it
523  // would actually be quite complex. Therefore we go through an
524  // alloca.
525  endOfInit = CGF.CreateTempAlloca(begin->getType(), CGF.getPointerAlign(),
526  "arrayinit.endOfInit");
527  cleanupDominator = Builder.CreateStore(begin, endOfInit);
528  CGF.pushIrregularPartialArrayCleanup(begin, endOfInit, elementType,
529  elementAlign,
530  CGF.getDestroyer(dtorKind));
531  cleanup = CGF.EHStack.stable_begin();
532 
533  // Otherwise, remember that we didn't need a cleanup.
534  } else {
535  dtorKind = QualType::DK_none;
536  }
537 
538  llvm::Value *one = llvm::ConstantInt::get(CGF.SizeTy, 1);
539 
540  // The 'current element to initialize'. The invariants on this
541  // variable are complicated. Essentially, after each iteration of
542  // the loop, it points to the last initialized element, except
543  // that it points to the beginning of the array before any
544  // elements have been initialized.
545  llvm::Value *element = begin;
546 
547  // Emit the explicit initializers.
548  for (uint64_t i = 0; i != NumInitElements; ++i) {
549  // Advance to the next element.
550  if (i > 0) {
551  element = Builder.CreateInBoundsGEP(element, one, "arrayinit.element");
552 
553  // Tell the cleanup that it needs to destroy up to this
554  // element. TODO: some of these stores can be trivially
555  // observed to be unnecessary.
556  if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit);
557  }
558 
559  LValue elementLV =
560  CGF.MakeAddrLValue(Address(element, elementAlign), elementType);
561  EmitInitializationToLValue(E->getInit(i), elementLV);
562  }
563 
564  // Check whether there's a non-trivial array-fill expression.
565  Expr *filler = E->getArrayFiller();
566  bool hasTrivialFiller = isTrivialFiller(filler);
567 
568  // Any remaining elements need to be zero-initialized, possibly
569  // using the filler expression. We can skip this if the we're
570  // emitting to zeroed memory.
571  if (NumInitElements != NumArrayElements &&
572  !(Dest.isZeroed() && hasTrivialFiller &&
573  CGF.getTypes().isZeroInitializable(elementType))) {
574 
575  // Use an actual loop. This is basically
576  // do { *array++ = filler; } while (array != end);
577 
578  // Advance to the start of the rest of the array.
579  if (NumInitElements) {
580  element = Builder.CreateInBoundsGEP(element, one, "arrayinit.start");
581  if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit);
582  }
583 
584  // Compute the end of the array.
585  llvm::Value *end = Builder.CreateInBoundsGEP(begin,
586  llvm::ConstantInt::get(CGF.SizeTy, NumArrayElements),
587  "arrayinit.end");
588 
589  llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
590  llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body");
591 
592  // Jump into the body.
593  CGF.EmitBlock(bodyBB);
594  llvm::PHINode *currentElement =
595  Builder.CreatePHI(element->getType(), 2, "arrayinit.cur");
596  currentElement->addIncoming(element, entryBB);
597 
598  // Emit the actual filler expression.
599  {
600  // C++1z [class.temporary]p5:
601  // when a default constructor is called to initialize an element of
602  // an array with no corresponding initializer [...] the destruction of
603  // every temporary created in a default argument is sequenced before
604  // the construction of the next array element, if any
605  CodeGenFunction::RunCleanupsScope CleanupsScope(CGF);
606  LValue elementLV =
607  CGF.MakeAddrLValue(Address(currentElement, elementAlign), elementType);
608  if (filler)
609  EmitInitializationToLValue(filler, elementLV);
610  else
611  EmitNullInitializationToLValue(elementLV);
612  }
613 
614  // Move on to the next element.
615  llvm::Value *nextElement =
616  Builder.CreateInBoundsGEP(currentElement, one, "arrayinit.next");
617 
618  // Tell the EH cleanup that we finished with the last element.
619  if (endOfInit.isValid()) Builder.CreateStore(nextElement, endOfInit);
620 
621  // Leave the loop if we're done.
622  llvm::Value *done = Builder.CreateICmpEQ(nextElement, end,
623  "arrayinit.done");
624  llvm::BasicBlock *endBB = CGF.createBasicBlock("arrayinit.end");
625  Builder.CreateCondBr(done, endBB, bodyBB);
626  currentElement->addIncoming(nextElement, Builder.GetInsertBlock());
627 
628  CGF.EmitBlock(endBB);
629  }
630 
631  // Leave the partial-array cleanup if we entered one.
632  if (dtorKind) CGF.DeactivateCleanupBlock(cleanup, cleanupDominator);
633 }
634 
635 //===----------------------------------------------------------------------===//
636 // Visitor Methods
637 //===----------------------------------------------------------------------===//
638 
639 void AggExprEmitter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E){
640  Visit(E->GetTemporaryExpr());
641 }
642 
643 void AggExprEmitter::VisitOpaqueValueExpr(OpaqueValueExpr *e) {
644  // If this is a unique OVE, just visit its source expression.
645  if (e->isUnique())
646  Visit(e->getSourceExpr());
647  else
648  EmitFinalDestCopy(e->getType(), CGF.getOrCreateOpaqueLValueMapping(e));
649 }
650 
651 void
652 AggExprEmitter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
653  if (Dest.isPotentiallyAliased() &&
654  E->getType().isPODType(CGF.getContext())) {
655  // For a POD type, just emit a load of the lvalue + a copy, because our
656  // compound literal might alias the destination.
657  EmitAggLoadOfLValue(E);
658  return;
659  }
660 
661  AggValueSlot Slot = EnsureSlot(E->getType());
662  CGF.EmitAggExpr(E->getInitializer(), Slot);
663 }
664 
665 /// Attempt to look through various unimportant expressions to find a
666 /// cast of the given kind.
668  while (true) {
669  op = op->IgnoreParens();
670  if (CastExpr *castE = dyn_cast<CastExpr>(op)) {
671  if (castE->getCastKind() == kind)
672  return castE->getSubExpr();
673  if (castE->getCastKind() == CK_NoOp)
674  continue;
675  }
676  return nullptr;
677  }
678 }
679 
680 void AggExprEmitter::VisitCastExpr(CastExpr *E) {
681  if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
682  CGF.CGM.EmitExplicitCastExprType(ECE, &CGF);
683  switch (E->getCastKind()) {
684  case CK_Dynamic: {
685  // FIXME: Can this actually happen? We have no test coverage for it.
686  assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?");
687  LValue LV = CGF.EmitCheckedLValue(E->getSubExpr(),
689  // FIXME: Do we also need to handle property references here?
690  if (LV.isSimple())
691  CGF.EmitDynamicCast(LV.getAddress(), cast<CXXDynamicCastExpr>(E));
692  else
693  CGF.CGM.ErrorUnsupported(E, "non-simple lvalue dynamic_cast");
694 
695  if (!Dest.isIgnored())
696  CGF.CGM.ErrorUnsupported(E, "lvalue dynamic_cast with a destination");
697  break;
698  }
699 
700  case CK_ToUnion: {
701  // Evaluate even if the destination is ignored.
702  if (Dest.isIgnored()) {
704  /*ignoreResult=*/true);
705  break;
706  }
707 
708  // GCC union extension
709  QualType Ty = E->getSubExpr()->getType();
710  Address CastPtr =
711  Builder.CreateElementBitCast(Dest.getAddress(), CGF.ConvertType(Ty));
712  EmitInitializationToLValue(E->getSubExpr(),
713  CGF.MakeAddrLValue(CastPtr, Ty));
714  break;
715  }
716 
717  case CK_LValueToRValueBitCast: {
718  if (Dest.isIgnored()) {
720  /*ignoreResult=*/true);
721  break;
722  }
723 
724  LValue SourceLV = CGF.EmitLValue(E->getSubExpr());
725  Address SourceAddress =
726  Builder.CreateElementBitCast(SourceLV.getAddress(), CGF.Int8Ty);
727  Address DestAddress =
728  Builder.CreateElementBitCast(Dest.getAddress(), CGF.Int8Ty);
729  llvm::Value *SizeVal = llvm::ConstantInt::get(
730  CGF.SizeTy,
731  CGF.getContext().getTypeSizeInChars(E->getType()).getQuantity());
732  Builder.CreateMemCpy(DestAddress, SourceAddress, SizeVal);
733  break;
734  }
735 
736  case CK_DerivedToBase:
737  case CK_BaseToDerived:
738  case CK_UncheckedDerivedToBase: {
739  llvm_unreachable("cannot perform hierarchy conversion in EmitAggExpr: "
740  "should have been unpacked before we got here");
741  }
742 
743  case CK_NonAtomicToAtomic:
744  case CK_AtomicToNonAtomic: {
745  bool isToAtomic = (E->getCastKind() == CK_NonAtomicToAtomic);
746 
747  // Determine the atomic and value types.
749  QualType valueType = E->getType();
750  if (isToAtomic) std::swap(atomicType, valueType);
751 
752  assert(atomicType->isAtomicType());
753  assert(CGF.getContext().hasSameUnqualifiedType(valueType,
754  atomicType->castAs<AtomicType>()->getValueType()));
755 
756  // Just recurse normally if we're ignoring the result or the
757  // atomic type doesn't change representation.
758  if (Dest.isIgnored() || !CGF.CGM.isPaddedAtomicType(atomicType)) {
759  return Visit(E->getSubExpr());
760  }
761 
762  CastKind peepholeTarget =
763  (isToAtomic ? CK_AtomicToNonAtomic : CK_NonAtomicToAtomic);
764 
765  // These two cases are reverses of each other; try to peephole them.
766  if (Expr *op = findPeephole(E->getSubExpr(), peepholeTarget)) {
767  assert(CGF.getContext().hasSameUnqualifiedType(op->getType(),
768  E->getType()) &&
769  "peephole significantly changed types?");
770  return Visit(op);
771  }
772 
773  // If we're converting an r-value of non-atomic type to an r-value
774  // of atomic type, just emit directly into the relevant sub-object.
775  if (isToAtomic) {
776  AggValueSlot valueDest = Dest;
777  if (!valueDest.isIgnored() && CGF.CGM.isPaddedAtomicType(atomicType)) {
778  // Zero-initialize. (Strictly speaking, we only need to initialize
779  // the padding at the end, but this is simpler.)
780  if (!Dest.isZeroed())
782 
783  // Build a GEP to refer to the subobject.
784  Address valueAddr =
785  CGF.Builder.CreateStructGEP(valueDest.getAddress(), 0);
786  valueDest = AggValueSlot::forAddr(valueAddr,
787  valueDest.getQualifiers(),
788  valueDest.isExternallyDestructed(),
789  valueDest.requiresGCollection(),
790  valueDest.isPotentiallyAliased(),
793  }
794 
795  CGF.EmitAggExpr(E->getSubExpr(), valueDest);
796  return;
797  }
798 
799  // Otherwise, we're converting an atomic type to a non-atomic type.
800  // Make an atomic temporary, emit into that, and then copy the value out.
801  AggValueSlot atomicSlot =
802  CGF.CreateAggTemp(atomicType, "atomic-to-nonatomic.temp");
803  CGF.EmitAggExpr(E->getSubExpr(), atomicSlot);
804 
805  Address valueAddr = Builder.CreateStructGEP(atomicSlot.getAddress(), 0);
806  RValue rvalue = RValue::getAggregate(valueAddr, atomicSlot.isVolatile());
807  return EmitFinalDestCopy(valueType, rvalue);
808  }
809  case CK_AddressSpaceConversion:
810  return Visit(E->getSubExpr());
811 
812  case CK_LValueToRValue:
813  // If we're loading from a volatile type, force the destination
814  // into existence.
815  if (E->getSubExpr()->getType().isVolatileQualified()) {
816  EnsureDest(E->getType());
817  return Visit(E->getSubExpr());
818  }
819 
820  LLVM_FALLTHROUGH;
821 
822 
823  case CK_NoOp:
824  case CK_UserDefinedConversion:
825  case CK_ConstructorConversion:
827  E->getType()) &&
828  "Implicit cast types must be compatible");
829  Visit(E->getSubExpr());
830  break;
831 
832  case CK_LValueBitCast:
833  llvm_unreachable("should not be emitting lvalue bitcast as rvalue");
834 
835  case CK_Dependent:
836  case CK_BitCast:
837  case CK_ArrayToPointerDecay:
838  case CK_FunctionToPointerDecay:
839  case CK_NullToPointer:
840  case CK_NullToMemberPointer:
841  case CK_BaseToDerivedMemberPointer:
842  case CK_DerivedToBaseMemberPointer:
843  case CK_MemberPointerToBoolean:
844  case CK_ReinterpretMemberPointer:
845  case CK_IntegralToPointer:
846  case CK_PointerToIntegral:
847  case CK_PointerToBoolean:
848  case CK_ToVoid:
849  case CK_VectorSplat:
850  case CK_IntegralCast:
851  case CK_BooleanToSignedIntegral:
852  case CK_IntegralToBoolean:
853  case CK_IntegralToFloating:
854  case CK_FloatingToIntegral:
855  case CK_FloatingToBoolean:
856  case CK_FloatingCast:
857  case CK_CPointerToObjCPointerCast:
858  case CK_BlockPointerToObjCPointerCast:
859  case CK_AnyPointerToBlockPointerCast:
860  case CK_ObjCObjectLValueCast:
861  case CK_FloatingRealToComplex:
862  case CK_FloatingComplexToReal:
863  case CK_FloatingComplexToBoolean:
864  case CK_FloatingComplexCast:
865  case CK_FloatingComplexToIntegralComplex:
866  case CK_IntegralRealToComplex:
867  case CK_IntegralComplexToReal:
868  case CK_IntegralComplexToBoolean:
869  case CK_IntegralComplexCast:
870  case CK_IntegralComplexToFloatingComplex:
871  case CK_ARCProduceObject:
872  case CK_ARCConsumeObject:
873  case CK_ARCReclaimReturnedObject:
874  case CK_ARCExtendBlockObject:
875  case CK_CopyAndAutoreleaseBlockObject:
876  case CK_BuiltinFnToFnPtr:
877  case CK_ZeroToOCLOpaqueType:
878 
879  case CK_IntToOCLSampler:
880  case CK_FixedPointCast:
881  case CK_FixedPointToBoolean:
882  case CK_FixedPointToIntegral:
883  case CK_IntegralToFixedPoint:
884  llvm_unreachable("cast kind invalid for aggregate types");
885  }
886 }
887 
888 void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
889  if (E->getCallReturnType(CGF.getContext())->isReferenceType()) {
890  EmitAggLoadOfLValue(E);
891  return;
892  }
893 
894  withReturnValueSlot(E, [&](ReturnValueSlot Slot) {
895  return CGF.EmitCallExpr(E, Slot);
896  });
897 }
898 
899 void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
900  withReturnValueSlot(E, [&](ReturnValueSlot Slot) {
901  return CGF.EmitObjCMessageExpr(E, Slot);
902  });
903 }
904 
905 void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
906  CGF.EmitIgnoredExpr(E->getLHS());
907  Visit(E->getRHS());
908 }
909 
910 void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
912  CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest);
913 }
914 
919 };
920 
922  const BinaryOperator *E, llvm::Value *LHS,
924  const char *NameSuffix = "") {
925  QualType ArgTy = E->getLHS()->getType();
926  if (const ComplexType *CT = ArgTy->getAs<ComplexType>())
927  ArgTy = CT->getElementType();
928 
929  if (const auto *MPT = ArgTy->getAs<MemberPointerType>()) {
930  assert(Kind == CK_Equal &&
931  "member pointers may only be compared for equality");
933  CGF, LHS, RHS, MPT, /*IsInequality*/ false);
934  }
935 
936  // Compute the comparison instructions for the specified comparison kind.
937  struct CmpInstInfo {
938  const char *Name;
939  llvm::CmpInst::Predicate FCmp;
940  llvm::CmpInst::Predicate SCmp;
941  llvm::CmpInst::Predicate UCmp;
942  };
943  CmpInstInfo InstInfo = [&]() -> CmpInstInfo {
944  using FI = llvm::FCmpInst;
945  using II = llvm::ICmpInst;
946  switch (Kind) {
947  case CK_Less:
948  return {"cmp.lt", FI::FCMP_OLT, II::ICMP_SLT, II::ICMP_ULT};
949  case CK_Greater:
950  return {"cmp.gt", FI::FCMP_OGT, II::ICMP_SGT, II::ICMP_UGT};
951  case CK_Equal:
952  return {"cmp.eq", FI::FCMP_OEQ, II::ICMP_EQ, II::ICMP_EQ};
953  }
954  llvm_unreachable("Unrecognised CompareKind enum");
955  }();
956 
957  if (ArgTy->hasFloatingRepresentation())
958  return Builder.CreateFCmp(InstInfo.FCmp, LHS, RHS,
959  llvm::Twine(InstInfo.Name) + NameSuffix);
960  if (ArgTy->isIntegralOrEnumerationType() || ArgTy->isPointerType()) {
961  auto Inst =
962  ArgTy->hasSignedIntegerRepresentation() ? InstInfo.SCmp : InstInfo.UCmp;
963  return Builder.CreateICmp(Inst, LHS, RHS,
964  llvm::Twine(InstInfo.Name) + NameSuffix);
965  }
966 
967  llvm_unreachable("unsupported aggregate binary expression should have "
968  "already been handled");
969 }
970 
971 void AggExprEmitter::VisitBinCmp(const BinaryOperator *E) {
972  using llvm::BasicBlock;
973  using llvm::PHINode;
974  using llvm::Value;
975  assert(CGF.getContext().hasSameType(E->getLHS()->getType(),
976  E->getRHS()->getType()));
977  const ComparisonCategoryInfo &CmpInfo =
979  assert(CmpInfo.Record->isTriviallyCopyable() &&
980  "cannot copy non-trivially copyable aggregate");
981 
982  QualType ArgTy = E->getLHS()->getType();
983 
984  // TODO: Handle comparing these types.
985  if (ArgTy->isVectorType())
986  return CGF.ErrorUnsupported(
987  E, "aggregate three-way comparison with vector arguments");
988  if (!ArgTy->isIntegralOrEnumerationType() && !ArgTy->isRealFloatingType() &&
989  !ArgTy->isNullPtrType() && !ArgTy->isPointerType() &&
990  !ArgTy->isMemberPointerType() && !ArgTy->isAnyComplexType()) {
991  return CGF.ErrorUnsupported(E, "aggregate three-way comparison");
992  }
993  bool IsComplex = ArgTy->isAnyComplexType();
994 
995  // Evaluate the operands to the expression and extract their values.
996  auto EmitOperand = [&](Expr *E) -> std::pair<Value *, Value *> {
997  RValue RV = CGF.EmitAnyExpr(E);
998  if (RV.isScalar())
999  return {RV.getScalarVal(), nullptr};
1000  if (RV.isAggregate())
1001  return {RV.getAggregatePointer(), nullptr};
1002  assert(RV.isComplex());
1003  return RV.getComplexVal();
1004  };
1005  auto LHSValues = EmitOperand(E->getLHS()),
1006  RHSValues = EmitOperand(E->getRHS());
1007 
1008  auto EmitCmp = [&](CompareKind K) {
1009  Value *Cmp = EmitCompare(Builder, CGF, E, LHSValues.first, RHSValues.first,
1010  K, IsComplex ? ".r" : "");
1011  if (!IsComplex)
1012  return Cmp;
1013  assert(K == CompareKind::CK_Equal);
1014  Value *CmpImag = EmitCompare(Builder, CGF, E, LHSValues.second,
1015  RHSValues.second, K, ".i");
1016  return Builder.CreateAnd(Cmp, CmpImag, "and.eq");
1017  };
1018  auto EmitCmpRes = [&](const ComparisonCategoryInfo::ValueInfo *VInfo) {
1019  return Builder.getInt(VInfo->getIntValue());
1020  };
1021 
1022  Value *Select;
1023  if (ArgTy->isNullPtrType()) {
1024  Select = EmitCmpRes(CmpInfo.getEqualOrEquiv());
1025  } else if (CmpInfo.isEquality()) {
1026  Select = Builder.CreateSelect(
1027  EmitCmp(CK_Equal), EmitCmpRes(CmpInfo.getEqualOrEquiv()),
1028  EmitCmpRes(CmpInfo.getNonequalOrNonequiv()), "sel.eq");
1029  } else if (!CmpInfo.isPartial()) {
1030  Value *SelectOne =
1031  Builder.CreateSelect(EmitCmp(CK_Less), EmitCmpRes(CmpInfo.getLess()),
1032  EmitCmpRes(CmpInfo.getGreater()), "sel.lt");
1033  Select = Builder.CreateSelect(EmitCmp(CK_Equal),
1034  EmitCmpRes(CmpInfo.getEqualOrEquiv()),
1035  SelectOne, "sel.eq");
1036  } else {
1037  Value *SelectEq = Builder.CreateSelect(
1038  EmitCmp(CK_Equal), EmitCmpRes(CmpInfo.getEqualOrEquiv()),
1039  EmitCmpRes(CmpInfo.getUnordered()), "sel.eq");
1040  Value *SelectGT = Builder.CreateSelect(EmitCmp(CK_Greater),
1041  EmitCmpRes(CmpInfo.getGreater()),
1042  SelectEq, "sel.gt");
1043  Select = Builder.CreateSelect(
1044  EmitCmp(CK_Less), EmitCmpRes(CmpInfo.getLess()), SelectGT, "sel.lt");
1045  }
1046  // Create the return value in the destination slot.
1047  EnsureDest(E->getType());
1048  LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1049 
1050  // Emit the address of the first (and only) field in the comparison category
1051  // type, and initialize it from the constant integer value selected above.
1053  DestLV, *CmpInfo.Record->field_begin());
1054  CGF.EmitStoreThroughLValue(RValue::get(Select), FieldLV, /*IsInit*/ true);
1055 
1056  // All done! The result is in the Dest slot.
1057 }
1058 
1059 void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
1060  if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI)
1061  VisitPointerToDataMemberBinaryOperator(E);
1062  else
1063  CGF.ErrorUnsupported(E, "aggregate binary expression");
1064 }
1065 
1066 void AggExprEmitter::VisitPointerToDataMemberBinaryOperator(
1067  const BinaryOperator *E) {
1069  EmitFinalDestCopy(E->getType(), LV);
1070 }
1071 
1072 /// Is the value of the given expression possibly a reference to or
1073 /// into a __block variable?
1074 static bool isBlockVarRef(const Expr *E) {
1075  // Make sure we look through parens.
1076  E = E->IgnoreParens();
1077 
1078  // Check for a direct reference to a __block variable.
1079  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
1080  const VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl());
1081  return (var && var->hasAttr<BlocksAttr>());
1082  }
1083 
1084  // More complicated stuff.
1085 
1086  // Binary operators.
1087  if (const BinaryOperator *op = dyn_cast<BinaryOperator>(E)) {
1088  // For an assignment or pointer-to-member operation, just care
1089  // about the LHS.
1090  if (op->isAssignmentOp() || op->isPtrMemOp())
1091  return isBlockVarRef(op->getLHS());
1092 
1093  // For a comma, just care about the RHS.
1094  if (op->getOpcode() == BO_Comma)
1095  return isBlockVarRef(op->getRHS());
1096 
1097  // FIXME: pointer arithmetic?
1098  return false;
1099 
1100  // Check both sides of a conditional operator.
1101  } else if (const AbstractConditionalOperator *op
1102  = dyn_cast<AbstractConditionalOperator>(E)) {
1103  return isBlockVarRef(op->getTrueExpr())
1104  || isBlockVarRef(op->getFalseExpr());
1105 
1106  // OVEs are required to support BinaryConditionalOperators.
1107  } else if (const OpaqueValueExpr *op
1108  = dyn_cast<OpaqueValueExpr>(E)) {
1109  if (const Expr *src = op->getSourceExpr())
1110  return isBlockVarRef(src);
1111 
1112  // Casts are necessary to get things like (*(int*)&var) = foo().
1113  // We don't really care about the kind of cast here, except
1114  // we don't want to look through l2r casts, because it's okay
1115  // to get the *value* in a __block variable.
1116  } else if (const CastExpr *cast = dyn_cast<CastExpr>(E)) {
1117  if (cast->getCastKind() == CK_LValueToRValue)
1118  return false;
1119  return isBlockVarRef(cast->getSubExpr());
1120 
1121  // Handle unary operators. Again, just aggressively look through
1122  // it, ignoring the operation.
1123  } else if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E)) {
1124  return isBlockVarRef(uop->getSubExpr());
1125 
1126  // Look into the base of a field access.
1127  } else if (const MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
1128  return isBlockVarRef(mem->getBase());
1129 
1130  // Look into the base of a subscript.
1131  } else if (const ArraySubscriptExpr *sub = dyn_cast<ArraySubscriptExpr>(E)) {
1132  return isBlockVarRef(sub->getBase());
1133  }
1134 
1135  return false;
1136 }
1137 
1138 void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
1139  // For an assignment to work, the value on the right has
1140  // to be compatible with the value on the left.
1141  assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
1142  E->getRHS()->getType())
1143  && "Invalid assignment");
1144 
1145  // If the LHS might be a __block variable, and the RHS can
1146  // potentially cause a block copy, we need to evaluate the RHS first
1147  // so that the assignment goes the right place.
1148  // This is pretty semantically fragile.
1149  if (isBlockVarRef(E->getLHS()) &&
1150  E->getRHS()->HasSideEffects(CGF.getContext())) {
1151  // Ensure that we have a destination, and evaluate the RHS into that.
1152  EnsureDest(E->getRHS()->getType());
1153  Visit(E->getRHS());
1154 
1155  // Now emit the LHS and copy into it.
1157 
1158  // That copy is an atomic copy if the LHS is atomic.
1159  if (LHS.getType()->isAtomicType() ||
1161  CGF.EmitAtomicStore(Dest.asRValue(), LHS, /*isInit*/ false);
1162  return;
1163  }
1164 
1165  EmitCopy(E->getLHS()->getType(),
1167  needsGC(E->getLHS()->getType()),
1170  Dest);
1171  return;
1172  }
1173 
1174  LValue LHS = CGF.EmitLValue(E->getLHS());
1175 
1176  // If we have an atomic type, evaluate into the destination and then
1177  // do an atomic copy.
1178  if (LHS.getType()->isAtomicType() ||
1180  EnsureDest(E->getRHS()->getType());
1181  Visit(E->getRHS());
1182  CGF.EmitAtomicStore(Dest.asRValue(), LHS, /*isInit*/ false);
1183  return;
1184  }
1185 
1186  // Codegen the RHS so that it stores directly into the LHS.
1187  AggValueSlot LHSSlot =
1189  needsGC(E->getLHS()->getType()),
1192  // A non-volatile aggregate destination might have volatile member.
1193  if (!LHSSlot.isVolatile() &&
1194  CGF.hasVolatileMember(E->getLHS()->getType()))
1195  LHSSlot.setVolatile(true);
1196 
1197  CGF.EmitAggExpr(E->getRHS(), LHSSlot);
1198 
1199  // Copy into the destination if the assignment isn't ignored.
1200  EmitFinalDestCopy(E->getType(), LHS);
1201 }
1202 
1203 void AggExprEmitter::
1204 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
1205  llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
1206  llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
1207  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
1208 
1209  // Bind the common expression if necessary.
1210  CodeGenFunction::OpaqueValueMapping binding(CGF, E);
1211 
1213  CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock,
1214  CGF.getProfileCount(E));
1215 
1216  // Save whether the destination's lifetime is externally managed.
1217  bool isExternallyDestructed = Dest.isExternallyDestructed();
1218 
1219  eval.begin(CGF);
1220  CGF.EmitBlock(LHSBlock);
1221  CGF.incrementProfileCounter(E);
1222  Visit(E->getTrueExpr());
1223  eval.end(CGF);
1224 
1225  assert(CGF.HaveInsertPoint() && "expression evaluation ended with no IP!");
1226  CGF.Builder.CreateBr(ContBlock);
1227 
1228  // If the result of an agg expression is unused, then the emission
1229  // of the LHS might need to create a destination slot. That's fine
1230  // with us, and we can safely emit the RHS into the same slot, but
1231  // we shouldn't claim that it's already being destructed.
1232  Dest.setExternallyDestructed(isExternallyDestructed);
1233 
1234  eval.begin(CGF);
1235  CGF.EmitBlock(RHSBlock);
1236  Visit(E->getFalseExpr());
1237  eval.end(CGF);
1238 
1239  CGF.EmitBlock(ContBlock);
1240 }
1241 
1242 void AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) {
1243  Visit(CE->getChosenSubExpr());
1244 }
1245 
1246 void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
1247  Address ArgValue = Address::invalid();
1248  Address ArgPtr = CGF.EmitVAArg(VE, ArgValue);
1249 
1250  // If EmitVAArg fails, emit an error.
1251  if (!ArgPtr.isValid()) {
1252  CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
1253  return;
1254  }
1255 
1256  EmitFinalDestCopy(VE->getType(), CGF.MakeAddrLValue(ArgPtr, VE->getType()));
1257 }
1258 
1259 void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1260  // Ensure that we have a slot, but if we already do, remember
1261  // whether it was externally destructed.
1262  bool wasExternallyDestructed = Dest.isExternallyDestructed();
1263  EnsureDest(E->getType());
1264 
1265  // We're going to push a destructor if there isn't already one.
1266  Dest.setExternallyDestructed();
1267 
1268  Visit(E->getSubExpr());
1269 
1270  // Push that destructor we promised.
1271  if (!wasExternallyDestructed)
1272  CGF.EmitCXXTemporary(E->getTemporary(), E->getType(), Dest.getAddress());
1273 }
1274 
1275 void
1276 AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {
1277  AggValueSlot Slot = EnsureSlot(E->getType());
1278  CGF.EmitCXXConstructExpr(E, Slot);
1279 }
1280 
1281 void AggExprEmitter::VisitCXXInheritedCtorInitExpr(
1282  const CXXInheritedCtorInitExpr *E) {
1283  AggValueSlot Slot = EnsureSlot(E->getType());
1285  E->getConstructor(), E->constructsVBase(), Slot.getAddress(),
1286  E->inheritedFromVBase(), E);
1287 }
1288 
1289 void
1290 AggExprEmitter::VisitLambdaExpr(LambdaExpr *E) {
1291  AggValueSlot Slot = EnsureSlot(E->getType());
1292  LValue SlotLV = CGF.MakeAddrLValue(Slot.getAddress(), E->getType());
1293 
1294  // We'll need to enter cleanup scopes in case any of the element
1295  // initializers throws an exception.
1297  llvm::Instruction *CleanupDominator = nullptr;
1298 
1301  e = E->capture_init_end();
1302  i != e; ++i, ++CurField) {
1303  // Emit initialization
1304  LValue LV = CGF.EmitLValueForFieldInitialization(SlotLV, *CurField);
1305  if (CurField->hasCapturedVLAType()) {
1306  CGF.EmitLambdaVLACapture(CurField->getCapturedVLAType(), LV);
1307  continue;
1308  }
1309 
1310  EmitInitializationToLValue(*i, LV);
1311 
1312  // Push a destructor if necessary.
1313  if (QualType::DestructionKind DtorKind =
1314  CurField->getType().isDestructedType()) {
1315  assert(LV.isSimple());
1316  if (CGF.needsEHCleanup(DtorKind)) {
1317  if (!CleanupDominator)
1318  CleanupDominator = CGF.Builder.CreateAlignedLoad(
1319  CGF.Int8Ty,
1320  llvm::Constant::getNullValue(CGF.Int8PtrTy),
1321  CharUnits::One()); // placeholder
1322 
1323  CGF.pushDestroy(EHCleanup, LV.getAddress(), CurField->getType(),
1324  CGF.getDestroyer(DtorKind), false);
1325  Cleanups.push_back(CGF.EHStack.stable_begin());
1326  }
1327  }
1328  }
1329 
1330  // Deactivate all the partial cleanups in reverse order, which
1331  // generally means popping them.
1332  for (unsigned i = Cleanups.size(); i != 0; --i)
1333  CGF.DeactivateCleanupBlock(Cleanups[i-1], CleanupDominator);
1334 
1335  // Destroy the placeholder if we made one.
1336  if (CleanupDominator)
1337  CleanupDominator->eraseFromParent();
1338 }
1339 
1340 void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
1341  CGF.enterFullExpression(E);
1342  CodeGenFunction::RunCleanupsScope cleanups(CGF);
1343  Visit(E->getSubExpr());
1344 }
1345 
1346 void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1347  QualType T = E->getType();
1348  AggValueSlot Slot = EnsureSlot(T);
1349  EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T));
1350 }
1351 
1352 void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1353  QualType T = E->getType();
1354  AggValueSlot Slot = EnsureSlot(T);
1355  EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T));
1356 }
1357 
1358 /// isSimpleZero - If emitting this value will obviously just cause a store of
1359 /// zero to memory, return true. This can return false if uncertain, so it just
1360 /// handles simple cases.
1361 static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {
1362  E = E->IgnoreParens();
1363 
1364  // 0
1365  if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
1366  return IL->getValue() == 0;
1367  // +0.0
1368  if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E))
1369  return FL->getValue().isPosZero();
1370  // int()
1371  if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) &&
1372  CGF.getTypes().isZeroInitializable(E->getType()))
1373  return true;
1374  // (int*)0 - Null pointer expressions.
1375  if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
1376  return ICE->getCastKind() == CK_NullToPointer &&
1378  !E->HasSideEffects(CGF.getContext());
1379  // '\0'
1380  if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E))
1381  return CL->getValue() == 0;
1382 
1383  // Otherwise, hard case: conservatively return false.
1384  return false;
1385 }
1386 
1387 
1388 void
1389 AggExprEmitter::EmitInitializationToLValue(Expr *E, LValue LV) {
1390  QualType type = LV.getType();
1391  // FIXME: Ignore result?
1392  // FIXME: Are initializers affected by volatile?
1393  if (Dest.isZeroed() && isSimpleZero(E, CGF)) {
1394  // Storing "i32 0" to a zero'd memory location is a noop.
1395  return;
1396  } else if (isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) {
1397  return EmitNullInitializationToLValue(LV);
1398  } else if (isa<NoInitExpr>(E)) {
1399  // Do nothing.
1400  return;
1401  } else if (type->isReferenceType()) {
1402  RValue RV = CGF.EmitReferenceBindingToExpr(E);
1403  return CGF.EmitStoreThroughLValue(RV, LV);
1404  }
1405 
1406  switch (CGF.getEvaluationKind(type)) {
1407  case TEK_Complex:
1408  CGF.EmitComplexExprIntoLValue(E, LV, /*isInit*/ true);
1409  return;
1410  case TEK_Aggregate:
1416  Dest.isZeroed()));
1417  return;
1418  case TEK_Scalar:
1419  if (LV.isSimple()) {
1420  CGF.EmitScalarInit(E, /*D=*/nullptr, LV, /*Captured=*/false);
1421  } else {
1423  }
1424  return;
1425  }
1426  llvm_unreachable("bad evaluation kind");
1427 }
1428 
1429 void AggExprEmitter::EmitNullInitializationToLValue(LValue lv) {
1430  QualType type = lv.getType();
1431 
1432  // If the destination slot is already zeroed out before the aggregate is
1433  // copied into it, we don't have to emit any zeros here.
1434  if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(type))
1435  return;
1436 
1437  if (CGF.hasScalarEvaluationKind(type)) {
1438  // For non-aggregates, we can store the appropriate null constant.
1439  llvm::Value *null = CGF.CGM.EmitNullConstant(type);
1440  // Note that the following is not equivalent to
1441  // EmitStoreThroughBitfieldLValue for ARC types.
1442  if (lv.isBitField()) {
1444  } else {
1445  assert(lv.isSimple());
1446  CGF.EmitStoreOfScalar(null, lv, /* isInitialization */ true);
1447  }
1448  } else {
1449  // There's a potential optimization opportunity in combining
1450  // memsets; that would be easy for arrays, but relatively
1451  // difficult for structures with the current code.
1452  CGF.EmitNullInitialization(lv.getAddress(), lv.getType());
1453  }
1454 }
1455 
1456 void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
1457 #if 0
1458  // FIXME: Assess perf here? Figure out what cases are worth optimizing here
1459  // (Length of globals? Chunks of zeroed-out space?).
1460  //
1461  // If we can, prefer a copy from a global; this is a lot less code for long
1462  // globals, and it's easier for the current optimizers to analyze.
1463  if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) {
1464  llvm::GlobalVariable* GV =
1465  new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true,
1467  EmitFinalDestCopy(E->getType(), CGF.MakeAddrLValue(GV, E->getType()));
1468  return;
1469  }
1470 #endif
1471  if (E->hadArrayRangeDesignator())
1472  CGF.ErrorUnsupported(E, "GNU array range designator extension");
1473 
1474  if (E->isTransparent())
1475  return Visit(E->getInit(0));
1476 
1477  AggValueSlot Dest = EnsureSlot(E->getType());
1478 
1479  LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1480 
1481  // Handle initialization of an array.
1482  if (E->getType()->isArrayType()) {
1483  auto AType = cast<llvm::ArrayType>(Dest.getAddress().getElementType());
1484  EmitArrayInit(Dest.getAddress(), AType, E->getType(), E);
1485  return;
1486  }
1487 
1488  assert(E->getType()->isRecordType() && "Only support structs/unions here!");
1489 
1490  // Do struct initialization; this code just sets each individual member
1491  // to the approprate value. This makes bitfield support automatic;
1492  // the disadvantage is that the generated code is more difficult for
1493  // the optimizer, especially with bitfields.
1494  unsigned NumInitElements = E->getNumInits();
1495  RecordDecl *record = E->getType()->castAs<RecordType>()->getDecl();
1496 
1497  // We'll need to enter cleanup scopes in case any of the element
1498  // initializers throws an exception.
1500  llvm::Instruction *cleanupDominator = nullptr;
1501  auto addCleanup = [&](const EHScopeStack::stable_iterator &cleanup) {
1502  cleanups.push_back(cleanup);
1503  if (!cleanupDominator) // create placeholder once needed
1504  cleanupDominator = CGF.Builder.CreateAlignedLoad(
1505  CGF.Int8Ty, llvm::Constant::getNullValue(CGF.Int8PtrTy),
1506  CharUnits::One());
1507  };
1508 
1509  unsigned curInitIndex = 0;
1510 
1511  // Emit initialization of base classes.
1512  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(record)) {
1513  assert(E->getNumInits() >= CXXRD->getNumBases() &&
1514  "missing initializer for base class");
1515  for (auto &Base : CXXRD->bases()) {
1516  assert(!Base.isVirtual() && "should not see vbases here");
1517  auto *BaseRD = Base.getType()->getAsCXXRecordDecl();
1519  Dest.getAddress(), CXXRD, BaseRD,
1520  /*isBaseVirtual*/ false);
1522  V, Qualifiers(),
1526  CGF.getOverlapForBaseInit(CXXRD, BaseRD, Base.isVirtual()));
1527  CGF.EmitAggExpr(E->getInit(curInitIndex++), AggSlot);
1528 
1529  if (QualType::DestructionKind dtorKind =
1530  Base.getType().isDestructedType()) {
1531  CGF.pushDestroy(dtorKind, V, Base.getType());
1532  addCleanup(CGF.EHStack.stable_begin());
1533  }
1534  }
1535  }
1536 
1537  // Prepare a 'this' for CXXDefaultInitExprs.
1539 
1540  if (record->isUnion()) {
1541  // Only initialize one field of a union. The field itself is
1542  // specified by the initializer list.
1543  if (!E->getInitializedFieldInUnion()) {
1544  // Empty union; we have nothing to do.
1545 
1546 #ifndef NDEBUG
1547  // Make sure that it's really an empty and not a failure of
1548  // semantic analysis.
1549  for (const auto *Field : record->fields())
1550  assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
1551 #endif
1552  return;
1553  }
1554 
1555  // FIXME: volatility
1556  FieldDecl *Field = E->getInitializedFieldInUnion();
1557 
1558  LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestLV, Field);
1559  if (NumInitElements) {
1560  // Store the initializer into the field
1561  EmitInitializationToLValue(E->getInit(0), FieldLoc);
1562  } else {
1563  // Default-initialize to null.
1564  EmitNullInitializationToLValue(FieldLoc);
1565  }
1566 
1567  return;
1568  }
1569 
1570  // Here we iterate over the fields; this makes it simpler to both
1571  // default-initialize fields and skip over unnamed fields.
1572  for (const auto *field : record->fields()) {
1573  // We're done once we hit the flexible array member.
1574  if (field->getType()->isIncompleteArrayType())
1575  break;
1576 
1577  // Always skip anonymous bitfields.
1578  if (field->isUnnamedBitfield())
1579  continue;
1580 
1581  // We're done if we reach the end of the explicit initializers, we
1582  // have a zeroed object, and the rest of the fields are
1583  // zero-initializable.
1584  if (curInitIndex == NumInitElements && Dest.isZeroed() &&
1585  CGF.getTypes().isZeroInitializable(E->getType()))
1586  break;
1587 
1588 
1589  LValue LV = CGF.EmitLValueForFieldInitialization(DestLV, field);
1590  // We never generate write-barries for initialized fields.
1591  LV.setNonGC(true);
1592 
1593  if (curInitIndex < NumInitElements) {
1594  // Store the initializer into the field.
1595  EmitInitializationToLValue(E->getInit(curInitIndex++), LV);
1596  } else {
1597  // We're out of initializers; default-initialize to null
1598  EmitNullInitializationToLValue(LV);
1599  }
1600 
1601  // Push a destructor if necessary.
1602  // FIXME: if we have an array of structures, all explicitly
1603  // initialized, we can end up pushing a linear number of cleanups.
1604  bool pushedCleanup = false;
1605  if (QualType::DestructionKind dtorKind
1606  = field->getType().isDestructedType()) {
1607  assert(LV.isSimple());
1608  if (CGF.needsEHCleanup(dtorKind)) {
1609  CGF.pushDestroy(EHCleanup, LV.getAddress(), field->getType(),
1610  CGF.getDestroyer(dtorKind), false);
1611  addCleanup(CGF.EHStack.stable_begin());
1612  pushedCleanup = true;
1613  }
1614  }
1615 
1616  // If the GEP didn't get used because of a dead zero init or something
1617  // else, clean it up for -O0 builds and general tidiness.
1618  if (!pushedCleanup && LV.isSimple())
1619  if (llvm::GetElementPtrInst *GEP =
1620  dyn_cast<llvm::GetElementPtrInst>(LV.getPointer()))
1621  if (GEP->use_empty())
1622  GEP->eraseFromParent();
1623  }
1624 
1625  // Deactivate all the partial cleanups in reverse order, which
1626  // generally means popping them.
1627  assert((cleanupDominator || cleanups.empty()) &&
1628  "Missing cleanupDominator before deactivating cleanup blocks");
1629  for (unsigned i = cleanups.size(); i != 0; --i)
1630  CGF.DeactivateCleanupBlock(cleanups[i-1], cleanupDominator);
1631 
1632  // Destroy the placeholder if we made one.
1633  if (cleanupDominator)
1634  cleanupDominator->eraseFromParent();
1635 }
1636 
1637 void AggExprEmitter::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E,
1638  llvm::Value *outerBegin) {
1639  // Emit the common subexpression.
1641 
1642  Address destPtr = EnsureSlot(E->getType()).getAddress();
1643  uint64_t numElements = E->getArraySize().getZExtValue();
1644 
1645  if (!numElements)
1646  return;
1647 
1648  // destPtr is an array*. Construct an elementType* by drilling down a level.
1649  llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
1650  llvm::Value *indices[] = {zero, zero};
1651  llvm::Value *begin = Builder.CreateInBoundsGEP(destPtr.getPointer(), indices,
1652  "arrayinit.begin");
1653 
1654  // Prepare to special-case multidimensional array initialization: we avoid
1655  // emitting multiple destructor loops in that case.
1656  if (!outerBegin)
1657  outerBegin = begin;
1658  ArrayInitLoopExpr *InnerLoop = dyn_cast<ArrayInitLoopExpr>(E->getSubExpr());
1659 
1660  QualType elementType =
1661  CGF.getContext().getAsArrayType(E->getType())->getElementType();
1662  CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
1663  CharUnits elementAlign =
1664  destPtr.getAlignment().alignmentOfArrayElement(elementSize);
1665 
1666  llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
1667  llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body");
1668 
1669  // Jump into the body.
1670  CGF.EmitBlock(bodyBB);
1671  llvm::PHINode *index =
1672  Builder.CreatePHI(zero->getType(), 2, "arrayinit.index");
1673  index->addIncoming(zero, entryBB);
1674  llvm::Value *element = Builder.CreateInBoundsGEP(begin, index);
1675 
1676  // Prepare for a cleanup.
1677  QualType::DestructionKind dtorKind = elementType.isDestructedType();
1679  if (CGF.needsEHCleanup(dtorKind) && !InnerLoop) {
1680  if (outerBegin->getType() != element->getType())
1681  outerBegin = Builder.CreateBitCast(outerBegin, element->getType());
1682  CGF.pushRegularPartialArrayCleanup(outerBegin, element, elementType,
1683  elementAlign,
1684  CGF.getDestroyer(dtorKind));
1685  cleanup = CGF.EHStack.stable_begin();
1686  } else {
1687  dtorKind = QualType::DK_none;
1688  }
1689 
1690  // Emit the actual filler expression.
1691  {
1692  // Temporaries created in an array initialization loop are destroyed
1693  // at the end of each iteration.
1694  CodeGenFunction::RunCleanupsScope CleanupsScope(CGF);
1696  LValue elementLV =
1697  CGF.MakeAddrLValue(Address(element, elementAlign), elementType);
1698 
1699  if (InnerLoop) {
1700  // If the subexpression is an ArrayInitLoopExpr, share its cleanup.
1701  auto elementSlot = AggValueSlot::forLValue(
1702  elementLV, AggValueSlot::IsDestructed,
1706  AggExprEmitter(CGF, elementSlot, false)
1707  .VisitArrayInitLoopExpr(InnerLoop, outerBegin);
1708  } else
1709  EmitInitializationToLValue(E->getSubExpr(), elementLV);
1710  }
1711 
1712  // Move on to the next element.
1713  llvm::Value *nextIndex = Builder.CreateNUWAdd(
1714  index, llvm::ConstantInt::get(CGF.SizeTy, 1), "arrayinit.next");
1715  index->addIncoming(nextIndex, Builder.GetInsertBlock());
1716 
1717  // Leave the loop if we're done.
1718  llvm::Value *done = Builder.CreateICmpEQ(
1719  nextIndex, llvm::ConstantInt::get(CGF.SizeTy, numElements),
1720  "arrayinit.done");
1721  llvm::BasicBlock *endBB = CGF.createBasicBlock("arrayinit.end");
1722  Builder.CreateCondBr(done, endBB, bodyBB);
1723 
1724  CGF.EmitBlock(endBB);
1725 
1726  // Leave the partial-array cleanup if we entered one.
1727  if (dtorKind)
1728  CGF.DeactivateCleanupBlock(cleanup, index);
1729 }
1730 
1731 void AggExprEmitter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1732  AggValueSlot Dest = EnsureSlot(E->getType());
1733 
1734  LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1735  EmitInitializationToLValue(E->getBase(), DestLV);
1736  VisitInitListExpr(E->getUpdater());
1737 }
1738 
1739 //===----------------------------------------------------------------------===//
1740 // Entry Points into this File
1741 //===----------------------------------------------------------------------===//
1742 
1743 /// GetNumNonZeroBytesInInit - Get an approximate count of the number of
1744 /// non-zero bytes that will be stored when outputting the initializer for the
1745 /// specified initializer expression.
1747  E = E->IgnoreParens();
1748 
1749  // 0 and 0.0 won't require any non-zero stores!
1750  if (isSimpleZero(E, CGF)) return CharUnits::Zero();
1751 
1752  // If this is an initlist expr, sum up the size of sizes of the (present)
1753  // elements. If this is something weird, assume the whole thing is non-zero.
1754  const InitListExpr *ILE = dyn_cast<InitListExpr>(E);
1755  while (ILE && ILE->isTransparent())
1756  ILE = dyn_cast<InitListExpr>(ILE->getInit(0));
1757  if (!ILE || !CGF.getTypes().isZeroInitializable(ILE->getType()))
1758  return CGF.getContext().getTypeSizeInChars(E->getType());
1759 
1760  // InitListExprs for structs have to be handled carefully. If there are
1761  // reference members, we need to consider the size of the reference, not the
1762  // referencee. InitListExprs for unions and arrays can't have references.
1763  if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
1764  if (!RT->isUnionType()) {
1765  RecordDecl *SD = RT->getDecl();
1766  CharUnits NumNonZeroBytes = CharUnits::Zero();
1767 
1768  unsigned ILEElement = 0;
1769  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(SD))
1770  while (ILEElement != CXXRD->getNumBases())
1771  NumNonZeroBytes +=
1772  GetNumNonZeroBytesInInit(ILE->getInit(ILEElement++), CGF);
1773  for (const auto *Field : SD->fields()) {
1774  // We're done once we hit the flexible array member or run out of
1775  // InitListExpr elements.
1776  if (Field->getType()->isIncompleteArrayType() ||
1777  ILEElement == ILE->getNumInits())
1778  break;
1779  if (Field->isUnnamedBitfield())
1780  continue;
1781 
1782  const Expr *E = ILE->getInit(ILEElement++);
1783 
1784  // Reference values are always non-null and have the width of a pointer.
1785  if (Field->getType()->isReferenceType())
1786  NumNonZeroBytes += CGF.getContext().toCharUnitsFromBits(
1787  CGF.getTarget().getPointerWidth(0));
1788  else
1789  NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF);
1790  }
1791 
1792  return NumNonZeroBytes;
1793  }
1794  }
1795 
1796 
1797  CharUnits NumNonZeroBytes = CharUnits::Zero();
1798  for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
1799  NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF);
1800  return NumNonZeroBytes;
1801 }
1802 
1803 /// CheckAggExprForMemSetUse - If the initializer is large and has a lot of
1804 /// zeros in it, emit a memset and avoid storing the individual zeros.
1805 ///
1806 static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,
1807  CodeGenFunction &CGF) {
1808  // If the slot is already known to be zeroed, nothing to do. Don't mess with
1809  // volatile stores.
1810  if (Slot.isZeroed() || Slot.isVolatile() || !Slot.getAddress().isValid())
1811  return;
1812 
1813  // C++ objects with a user-declared constructor don't need zero'ing.
1814  if (CGF.getLangOpts().CPlusPlus)
1815  if (const RecordType *RT = CGF.getContext()
1816  .getBaseElementType(E->getType())->getAs<RecordType>()) {
1817  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1818  if (RD->hasUserDeclaredConstructor())
1819  return;
1820  }
1821 
1822  // If the type is 16-bytes or smaller, prefer individual stores over memset.
1823  CharUnits Size = Slot.getPreferredSize(CGF.getContext(), E->getType());
1824  if (Size <= CharUnits::fromQuantity(16))
1825  return;
1826 
1827  // Check to see if over 3/4 of the initializer are known to be zero. If so,
1828  // we prefer to emit memset + individual stores for the rest.
1829  CharUnits NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF);
1830  if (NumNonZeroBytes*4 > Size)
1831  return;
1832 
1833  // Okay, it seems like a good idea to use an initial memset, emit the call.
1834  llvm::Constant *SizeVal = CGF.Builder.getInt64(Size.getQuantity());
1835 
1836  Address Loc = Slot.getAddress();
1837  Loc = CGF.Builder.CreateElementBitCast(Loc, CGF.Int8Ty);
1838  CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal, false);
1839 
1840  // Tell the AggExprEmitter that the slot is known zero.
1841  Slot.setZeroed();
1842 }
1843 
1844 
1845 
1846 
1847 /// EmitAggExpr - Emit the computation of the specified expression of aggregate
1848 /// type. The result is computed into DestPtr. Note that if DestPtr is null,
1849 /// the value of the aggregate expression is not needed. If VolatileDest is
1850 /// true, DestPtr cannot be 0.
1852  assert(E && hasAggregateEvaluationKind(E->getType()) &&
1853  "Invalid aggregate expression to emit");
1854  assert((Slot.getAddress().isValid() || Slot.isIgnored()) &&
1855  "slot has bits but no address");
1856 
1857  // Optimize the slot if possible.
1858  CheckAggExprForMemSetUse(Slot, E, *this);
1859 
1860  AggExprEmitter(*this, Slot, Slot.isIgnored()).Visit(const_cast<Expr*>(E));
1861 }
1862 
1864  assert(hasAggregateEvaluationKind(E->getType()) && "Invalid argument!");
1865  Address Temp = CreateMemTemp(E->getType());
1866  LValue LV = MakeAddrLValue(Temp, E->getType());
1871  return LV;
1872 }
1873 
1876  if (!FD->hasAttr<NoUniqueAddressAttr>() || !FD->getType()->isRecordType())
1878 
1879  // If the field lies entirely within the enclosing class's nvsize, its tail
1880  // padding cannot overlap any already-initialized object. (The only subobjects
1881  // with greater addresses that might already be initialized are vbases.)
1882  const RecordDecl *ClassRD = FD->getParent();
1883  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(ClassRD);
1884  if (Layout.getFieldOffset(FD->getFieldIndex()) +
1885  getContext().getTypeSize(FD->getType()) <=
1886  (uint64_t)getContext().toBits(Layout.getNonVirtualSize()))
1888 
1889  // The tail padding may contain values we need to preserve.
1890  return AggValueSlot::MayOverlap;
1891 }
1892 
1894  const CXXRecordDecl *RD, const CXXRecordDecl *BaseRD, bool IsVirtual) {
1895  // If the most-derived object is a field declared with [[no_unique_address]],
1896  // the tail padding of any virtual base could be reused for other subobjects
1897  // of that field's class.
1898  if (IsVirtual)
1899  return AggValueSlot::MayOverlap;
1900 
1901  // If the base class is laid out entirely within the nvsize of the derived
1902  // class, its tail padding cannot yet be initialized, so we can issue
1903  // stores at the full width of the base class.
1904  const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD);
1905  if (Layout.getBaseClassOffset(BaseRD) +
1906  getContext().getASTRecordLayout(BaseRD).getSize() <=
1907  Layout.getNonVirtualSize())
1909 
1910  // The tail padding may contain values we need to preserve.
1911  return AggValueSlot::MayOverlap;
1912 }
1913 
1915  AggValueSlot::Overlap_t MayOverlap,
1916  bool isVolatile) {
1917  assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
1918 
1919  Address DestPtr = Dest.getAddress();
1920  Address SrcPtr = Src.getAddress();
1921 
1922  if (getLangOpts().CPlusPlus) {
1923  if (const RecordType *RT = Ty->getAs<RecordType>()) {
1924  CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
1925  assert((Record->hasTrivialCopyConstructor() ||
1926  Record->hasTrivialCopyAssignment() ||
1927  Record->hasTrivialMoveConstructor() ||
1928  Record->hasTrivialMoveAssignment() ||
1929  Record->isUnion()) &&
1930  "Trying to aggregate-copy a type without a trivial copy/move "
1931  "constructor or assignment operator");
1932  // Ignore empty classes in C++.
1933  if (Record->isEmpty())
1934  return;
1935  }
1936  }
1937 
1938  // Aggregate assignment turns into llvm.memcpy. This is almost valid per
1939  // C99 6.5.16.1p3, which states "If the value being stored in an object is
1940  // read from another object that overlaps in anyway the storage of the first
1941  // object, then the overlap shall be exact and the two objects shall have
1942  // qualified or unqualified versions of a compatible type."
1943  //
1944  // memcpy is not defined if the source and destination pointers are exactly
1945  // equal, but other compilers do this optimization, and almost every memcpy
1946  // implementation handles this case safely. If there is a libc that does not
1947  // safely handle this, we can add a target hook.
1948 
1949  // Get data size info for this aggregate. Don't copy the tail padding if this
1950  // might be a potentially-overlapping subobject, since the tail padding might
1951  // be occupied by a different object. Otherwise, copying it is fine.
1952  std::pair<CharUnits, CharUnits> TypeInfo;
1953  if (MayOverlap)
1954  TypeInfo = getContext().getTypeInfoDataSizeInChars(Ty);
1955  else
1956  TypeInfo = getContext().getTypeInfoInChars(Ty);
1957 
1958  llvm::Value *SizeVal = nullptr;
1959  if (TypeInfo.first.isZero()) {
1960  // But note that getTypeInfo returns 0 for a VLA.
1961  if (auto *VAT = dyn_cast_or_null<VariableArrayType>(
1962  getContext().getAsArrayType(Ty))) {
1963  QualType BaseEltTy;
1964  SizeVal = emitArrayLength(VAT, BaseEltTy, DestPtr);
1965  TypeInfo = getContext().getTypeInfoInChars(BaseEltTy);
1966  assert(!TypeInfo.first.isZero());
1967  SizeVal = Builder.CreateNUWMul(
1968  SizeVal,
1969  llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity()));
1970  }
1971  }
1972  if (!SizeVal) {
1973  SizeVal = llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity());
1974  }
1975 
1976  // FIXME: If we have a volatile struct, the optimizer can remove what might
1977  // appear to be `extra' memory ops:
1978  //
1979  // volatile struct { int i; } a, b;
1980  //
1981  // int main() {
1982  // a = b;
1983  // a = b;
1984  // }
1985  //
1986  // we need to use a different call here. We use isVolatile to indicate when
1987  // either the source or the destination is volatile.
1988 
1989  DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty);
1990  SrcPtr = Builder.CreateElementBitCast(SrcPtr, Int8Ty);
1991 
1992  // Don't do any of the memmove_collectable tests if GC isn't set.
1993  if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
1994  // fall through
1995  } else if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
1996  RecordDecl *Record = RecordTy->getDecl();
1997  if (Record->hasObjectMember()) {
1998  CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
1999  SizeVal);
2000  return;
2001  }
2002  } else if (Ty->isArrayType()) {
2003  QualType BaseType = getContext().getBaseElementType(Ty);
2004  if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
2005  if (RecordTy->getDecl()->hasObjectMember()) {
2006  CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
2007  SizeVal);
2008  return;
2009  }
2010  }
2011  }
2012 
2013  auto Inst = Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, isVolatile);
2014 
2015  // Determine the metadata to describe the position of any padding in this
2016  // memcpy, as well as the TBAA tags for the members of the struct, in case
2017  // the optimizer wishes to expand it in to scalar memory operations.
2018  if (llvm::MDNode *TBAAStructTag = CGM.getTBAAStructInfo(Ty))
2019  Inst->setMetadata(llvm::LLVMContext::MD_tbaa_struct, TBAAStructTag);
2020 
2021  if (CGM.getCodeGenOpts().NewStructPathTBAA) {
2022  TBAAAccessInfo TBAAInfo = CGM.mergeTBAAInfoForMemoryTransfer(
2023  Dest.getTBAAInfo(), Src.getTBAAInfo());
2024  CGM.DecorateInstructionWithTBAA(Inst, TBAAInfo);
2025  }
2026 }
bool isAggregate() const
Definition: CGValue.h:53
const llvm::DataLayout & getDataLayout() const
const Expr * getSubExpr() const
Definition: Expr.h:938
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.
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Definition: Expr.h:4143
Address getAddress() const
Definition: CGValue.h:582
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
Definition: CGDecl.cpp:2026
A (possibly-)qualified type.
Definition: Type.h:643
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2188
bool isArrayType() const
Definition: Type.h:6447
llvm::Type * ConvertTypeForMem(QualType T)
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount)
EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.
RValue EmitCoyieldExpr(const CoyieldExpr &E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
Address CreateMemTemp(QualType T, const Twine &Name="tmp", Address *Alloca=nullptr)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...
Definition: CGExpr.cpp:139
void enterFullExpression(const FullExpr *E)
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
Expr * getResultExpr()
Return the result expression of this controlling expression.
Definition: Expr.h:5398
CompoundStmt * getSubStmt()
Definition: Expr.h:3942
const Expr * getInit(unsigned Init) const
Definition: Expr.h:4423
Stmt - This represents one statement.
Definition: Stmt.h:66
Address GetAddressOfDirectBaseInCompleteClass(Address Value, const CXXRecordDecl *Derived, const CXXRecordDecl *Base, bool BaseIsVirtual)
GetAddressOfBaseOfCompleteClass - Convert the given pointer to a complete class to the given direct b...
Definition: CGClass.cpp:199
llvm::Constant * tryEmitForInitializer(const VarDecl &D)
Try to emit the initiaizer of the given declaration as an abstract constant.
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Definition: RecordLayout.h:232
NeedsGCBarriers_t requiresGCollection() const
Definition: CGValue.h:574
tooling::Replacements cleanup(const FormatStyle &Style, StringRef Code, ArrayRef< tooling::Range > Ranges, StringRef FileName="<stdin>")
Clean up any erroneous/redundant code in the given Ranges in Code.
Definition: Format.cpp:2454
llvm::Value * getPointer() const
Definition: CGValue.h:578
bool isRecordType() const
Definition: Type.h:6471
Address EmitVAArg(VAArgExpr *VE, Address &VAListAddr)
Generate code to get an argument from the passed in pointer and update it accordingly.
Definition: CGCall.cpp:4603
virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, Address DestPtr, Address SrcPtr, llvm::Value *Size)=0
RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e, AggValueSlot slot=AggValueSlot::ignored())
Definition: CGExpr.cpp:5087
RValue EmitCoawaitExpr(const CoawaitExpr &E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic, and whose semantics are that of the sole contained initializer)?
Definition: Expr.cpp:2286
Defines the C++ template declaration subclasses.
Opcode getOpcode() const
Definition: Expr.h:3444
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
Definition: Decl.cpp:3992
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1969
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined...
Definition: Decl.h:2832
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:1927
void EmitComplexExprIntoLValue(const Expr *E, LValue dest, bool isInit)
EmitComplexExprIntoLValue - Emit the given expression of complex type and place its result into the s...
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2860
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1422
bool hasTrivialMoveConstructor() const
Determine whether this class has a trivial move constructor (C++11 [class.copy]p12) ...
Definition: DeclCXX.h:1205
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
Definition: EHScopeStack.h:378
void setZeroed(bool V=true)
Definition: CGValue.h:614
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:6059
LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)
EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference...
Definition: CGExpr.cpp:4139
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4419
IsAliased_t isPotentiallyAliased() const
Definition: CGValue.h:594
void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit)
Definition: CGAtomic.cpp:1896
QualType getElementType() const
Definition: Type.h:2881
static bool isBlockVarRef(const Expr *E)
Is the value of the given expression possibly a reference to or into a __block variable?
Definition: CGExprAgg.cpp:1074
static Expr * findPeephole(Expr *op, CastKind kind)
Attempt to look through various unimportant expressions to find a cast of the given kind...
Definition: CGExprAgg.cpp:667
Represents a variable declaration or definition.
Definition: Decl.h:827
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:3052
OpaqueValueExpr * getCommonExpr() const
Get the common subexpression shared by all initializations (the source array).
Definition: Expr.h:5016
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6858
AggValueSlot::Overlap_t getOverlapForFieldInit(const FieldDecl *FD)
Determine whether a field initialization may overlap some other object.
Definition: CGExprAgg.cpp:1875
uint64_t getProfileCount(const Stmt *S)
Get the profiler&#39;s count for the given statement.
static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF)
isSimpleZero - If emitting this value will obviously just cause a store of zero to memory...
Definition: CGExprAgg.cpp:1361
LangAS
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:25
IsZeroed_t isZeroed() const
Definition: CGValue.h:615
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition: ExprCXX.h:715
llvm::Value * getPointer() const
Definition: Address.h:37
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will call.
Definition: ExprCXX.h:1648
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:1140
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
Definition: ExprCXX.h:3306
void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, llvm::Value **Result=nullptr)
EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints as EmitStoreThroughLValue.
Definition: CGExpr.cpp:2024
The collection of all-type qualifiers we support.
Definition: Type.h:137
CXXRecordDecl * getLambdaClass() const
Retrieve the class that corresponds to the lambda.
Definition: ExprCXX.cpp:1282
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g., it is a floating-point type or a vector thereof.
Definition: Type.cpp:2017
static CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF)
GetNumNonZeroBytesInInit - Get an approximate count of the number of non-zero bytes that will be stor...
Definition: CGExprAgg.cpp:1746
Represents a struct/union/class.
Definition: Decl.h:3662
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1100
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:360
const TargetInfo & getTarget() const
An object to manage conditionally-evaluated expressions.
Expr * getSemanticForm()
Get an equivalent semantic form for this expression.
Definition: ExprCXX.h:293
IsDestructed_t isExternallyDestructed() const
Definition: CGValue.h:550
Expr * GetTemporaryExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue...
Definition: ExprCXX.h:4457
Address getAddress() const
Definition: CGValue.h:326
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:160
llvm::Value * EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE)
Definition: CGExprCXX.cpp:2182
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
Definition: CGExpr.cpp:593
field_range fields() const
Definition: Decl.h:3877
Represents a member of a struct/union/class.
Definition: Decl.h:2643
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:4909
An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
bool Zero(InterpState &S, CodePtr OpPC)
Definition: Interp.h:815
bool isReferenceType() const
Definition: Type.h:6403
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1245
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Definition: EHScopeStack.h:80
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
Definition: Expr.h:1108
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
forAddr - Make a slot for an aggregate value.
Definition: CGValue.h:513
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
CharUnits getPreferredSize(ASTContext &Ctx, QualType Type) const
Get the preferred size to use when storing a value to this slot.
Definition: CGValue.h:622
Expr * getSubExpr()
Definition: Expr.h:3177
bool isPaddedAtomicType(QualType type)
static bool isTrivialFiller(Expr *E)
Determine if E is a trivial array filler, that is, one that is equivalent to zero-initialization.
Definition: CGExprAgg.cpp:447
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:6754
specific_decl_iterator< FieldDecl > field_iterator
Definition: Decl.h:3874
bool hadArrayRangeDesignator() const
Definition: Expr.h:4545
bool GE(InterpState &S, CodePtr OpPC)
Definition: Interp.h:255
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
RValue EmitAnyExpr(const Expr *E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
EmitAnyExpr - Emit code to compute the specified expression which can have any type.
Definition: CGExpr.cpp:194
void pushFullExprCleanup(CleanupKind kind, As... A)
pushFullExprCleanup - Push a cleanup to be run at the end of the current full-expression.
bool isGLValue() const
Definition: Expr.h:261
void EmitInheritedCXXConstructorCall(const CXXConstructorDecl *D, bool ForVirtualBase, Address This, bool InheritedFromVBase, const CXXInheritedCtorInitExpr *E)
Emit a call to a constructor inherited from a base class, passing the current constructor&#39;s arguments...
Definition: CGClass.cpp:2180
Describes an C or C++ initializer list.
Definition: Expr.h:4375
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:764
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:2295
static bool hasScalarEvaluationKind(QualType T)
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:38
bool isPartial() const
True iff the comparison is not totally ordered.
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
Definition: CharUnits.h:183
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
Definition: Type.cpp:2292
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
Definition: ExprCXX.h:1963
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:66
bool isComplex() const
Definition: CGValue.h:52
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3409
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6218
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind...
bool constructsVBase() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
Definition: ExprCXX.h:1652
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:274
void EmitLambdaVLACapture(const VariableArrayType *VAT, LValue LV)
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
field_iterator field_begin() const
Definition: Decl.cpp:4343
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
Definition: CGExpr.cpp:182
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3125
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1373
bool isSimple() const
Definition: CGValue.h:251
RValue EmitAtomicExpr(AtomicExpr *E)
Definition: CGAtomic.cpp:746
CXXTemporary * getTemporary()
Definition: ExprCXX.h:1392
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1818
bool isEquality() const
True iff the comparison category is an equality comparison.
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler&#39;s counter for the given statement by StepV.
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
Definition: CGExpr.cpp:106
const ComparisonCategoryInfo & getInfoForType(QualType Ty) const
Return the comparison category information as specified by getCategoryForType(Ty).
void callCStructMoveConstructor(LValue Dst, LValue Src)
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
Definition: CGValue.h:70
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1202
Checking the operand of a load. Must be suitably sized and aligned.
bool isTypeConstant(QualType QTy, bool ExcludeCtorDtor)
isTypeConstant - Determine whether an object of this type can be emitted as a constant.
const Expr * getExpr() const
Get the initialization expression that will be used.
Definition: ExprCXX.h:1307
RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())
Definition: CGObjC.cpp:484
bool hasAttr() const
Definition: DeclBase.h:542
bool isTriviallyCopyable() const
Determine whether this class is considered trivially copyable per (C++11 [class]p6).
Definition: DeclCXX.cpp:549
bool isValid() const
Definition: Address.h:35
void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest)
Definition: CGExprCXX.cpp:566
static CharUnits One()
One - Construct a CharUnits quantity of one.
Definition: CharUnits.h:58
CastKind
CastKind - The kind of operation required for a conversion.
RValue - This trivial value class is used to represent the result of an expression that is evaluated...
Definition: CGValue.h:38
InitListExpr * getUpdater() const
Definition: Expr.h:4967
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition: Expr.h:953
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:4216
bool isPointerZeroInitializable(QualType T)
Check if the pointer type can be zero-initialized (in the C++ sense) with an LLVM zeroinitializer...
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
Definition: RecordLayout.h:38
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
Definition: Expr.cpp:3343
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
PrimitiveCopyKind isNonTrivialToPrimitiveDestructiveMove() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
Definition: Type.cpp:2382
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
Definition: ExprCXX.h:2053
void callCStructMoveAssignmentOperator(LValue Dst, LValue Src)
This represents one expression.
Definition: Expr.h:108
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:122
static Address invalid()
Definition: Address.h:34
Qualifiers getQualifiers() const
Definition: CGValue.h:557
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
getComplexVal - Return the real/imag components of this complex value.
Definition: CGValue.h:65
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6923
#define V(N, I)
Definition: ASTContext.h:2921
Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
EmitCompoundStmt - Emit a compound statement {..} node.
Definition: CGStmt.cpp:379
unsigned getNumInits() const
Definition: Expr.h:4405
Expr * getSubExpr() const
Get the initializer to use for each array element.
Definition: Expr.h:5021
AggValueSlot CreateAggTemp(QualType T, const Twine &Name="tmp")
CreateAggTemp - Create a temporary memory object for the given aggregate type.
field_iterator field_end() const
Definition: Decl.h:3880
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:43
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
bool isAnyComplexType() const
Definition: Type.h:6479
const ValueInfo * getNonequalOrNonequiv() const
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
QualType getType() const
Definition: Expr.h:137
An RAII object to record that we&#39;re evaluating a statement expression.
TBAAAccessInfo getTBAAInfo() const
Definition: CGValue.h:307
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:201
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:950
llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:296
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:2021
const AstTypeMatcher< AtomicType > atomicType
Matches atomic types.
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:4209
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class...
Definition: DeclCXX.h:1182
const Expr * getSubExpr() const
Definition: Expr.h:1985
const Expr * getSubExpr() const
Definition: ExprCXX.h:1396
ASTContext & getContext() const
RValue EmitAtomicLoad(LValue LV, SourceLocation SL, AggValueSlot Slot=AggValueSlot::ignored())
Definition: CGAtomic.cpp:1472
void callCStructCopyAssignmentOperator(LValue Dst, LValue Src)
RecordDecl * getDecl() const
Definition: Type.h:4454
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
Definition: RecordLayout.h:190
const ValueInfo * getGreater() const
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:1050
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:141
Expr * getBase() const
Definition: Expr.h:4964
Kind
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1613
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:5673
bool inheritedFromVBase() const
Determine whether the inherited constructor is inherited from a virtual base of the object we constru...
Definition: ExprCXX.h:1662
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:2053
bool hasTrivialCopyAssignment() const
Determine whether this class has a trivial copy assignment operator (C++ [class.copy]p11, C++11 [class.copy]p25)
Definition: DeclCXX.h:1232
bool LValueIsSuitableForInlineAtomic(LValue Src)
An LValue is a candidate for having its loads and stores be made atomic if we are operating under /vo...
Definition: CGAtomic.cpp:1459
LangAS getAddressSpace() const
Return the address space of this type.
Definition: Type.h:6264
A saved depth on the scope stack.
Definition: EHScopeStack.h:106
Expr * getSubExpr() const
Definition: Expr.h:2051
LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK)
Same as EmitLValue but additionally we generate checking code to guard against undefined behavior...
Definition: CGExpr.cpp:1207
CastKind getCastKind() const
Definition: Expr.h:3171
const ValueInfo * getLess() const
LValue EmitAggExprToLValue(const Expr *E)
EmitAggExprToLValue - Emit the computation of the specified expression of aggregate type into a tempo...
Definition: CGExprAgg.cpp:1863
void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
DeactivateCleanupBlock - Deactivates the given cleanup block.
Definition: CGCleanup.cpp:1240
The type is a struct containing a field whose type is neither PCK_Trivial nor PCK_VolatileTrivial.
Definition: Type.h:1132
An aggregate value slot.
Definition: CGValue.h:436
llvm::Value * EmitLifetimeStart(uint64_t Size, llvm::Value *Addr)
Emit a lifetime.begin marker if some criteria are satisfied.
Definition: CGDecl.cpp:1286
A scoped helper to set the current debug location to the specified location or preferred location of ...
Definition: CGDebugInfo.h:711
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2450
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:182
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>, and corresponding __opencl_atomic_* for OpenCL 2.0.
Definition: Expr.h:5807
void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType, Address Ptr)
Emits all the code to cause the given temporary to be cleaned up.
Definition: CGCleanup.cpp:1272
static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E, CodeGenFunction &CGF)
CheckAggExprForMemSetUse - If the initializer is large and has a lot of zeros in it, emit a memset and avoid storing the individual zeros.
Definition: CGExprAgg.cpp:1806
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:1160
LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E)
Definition: CGExpr.cpp:4958
PrimitiveCopyKind isNonTrivialToPrimitiveCopy() const
Check if this is a non-trivial type that would cause a C struct transitively containing this type to ...
Definition: Type.cpp:2364
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3926
QualType getType() const
Definition: CGValue.h:263
RValue EmitCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue=ReturnValueSlot())
Definition: CGExpr.cpp:4508
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:4469
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2329
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:221
const Expr * getInitializer() const
Definition: Expr.h:3078
Expr * getLHS() const
Definition: Expr.h:3449
void setExternallyDestructed(bool destructed=true)
Definition: CGValue.h:553
Represents a C11 generic selection.
Definition: Expr.h:5206
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type, returning the result.
virtual llvm::Value * EmitMemberPointerComparison(CodeGenFunction &CGF, llvm::Value *L, llvm::Value *R, const MemberPointerType *MPT, bool Inequality)
Emit a comparison between two member pointers. Returns an i1.
Definition: CGCXXABI.cpp:80
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition: CGValue.h:58
QualType withVolatile() const
Definition: Type.h:823
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn&#39;t support the specified stmt yet.
This class organizes the cross-function state that is used while generating LLVM code.
void setVolatile(bool flag)
Definition: CGValue.h:563
Dataflow Directional Tag Classes.
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1878
AggValueSlot::Overlap_t getOverlapForBaseInit(const CXXRecordDecl *RD, const CXXRecordDecl *BaseRD, bool IsVirtual)
Determine whether a base class initialization may overlap some other object.
Definition: CGExprAgg.cpp:1893
static AggValueSlot ignored()
ignored - Returns an aggregate value slot indicating that the aggregate value is being ignored...
Definition: CGValue.h:498
CompareKind
Definition: CGExprAgg.cpp:915
A scope within which we are constructing the fields of an object which might use a CXXDefaultInitExpr...
LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its LValue mapping if it exists, otherwise create one...
Definition: CGExpr.cpp:4457
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:90
LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e)
Definition: CGExpr.cpp:5092
bool hasUserDeclaredConstructor() const
Determine whether this class has any user-declared constructors.
Definition: DeclCXX.h:749
Represents a &#39;co_yield&#39; expression.
Definition: ExprCXX.h:4792
const Expr * getExpr() const
Definition: ExprCXX.h:1241
U cast(CodeGen::Address addr)
Definition: Address.h:108
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
Checking the destination of a store. Must be suitably sized and aligned.
CXXRecordDecl * Record
The declaration for the comparison category type from the standard library.
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2804
bool isBitField() const
Definition: CGValue.h:253
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
llvm::Module & getModule() const
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
Definition: Expr.cpp:1496
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:2048
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type. ...
Definition: CGExprAgg.cpp:1851
void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)
Emit type info if type of an expression is a variably modified type.
Definition: CGExpr.cpp:1020
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4444
Complex values, per C99 6.2.5p11.
Definition: Type.h:2525
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2437
CodeGenTypes & getTypes() const
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Definition: Expr.h:3665
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:51
const llvm::APInt & getSize() const
Definition: Type.h:2929
bool isAtomicType() const
Definition: Type.h:6508
Represents a &#39;co_await&#39; expression.
Definition: ExprCXX.h:4705
bool isUnique() const
Definition: Expr.h:1116
llvm::Value * getAggregatePointer() const
Definition: CGValue.h:75
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
Definition: CGDecl.cpp:740
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2305
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:465
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:546
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1279
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
Overlap_t mayOverlap() const
Definition: CGValue.h:598
void callCStructCopyConstructor(LValue Dst, LValue Src)
static llvm::Value * EmitCompare(CGBuilderTy &Builder, CodeGenFunction &CGF, const BinaryOperator *E, llvm::Value *LHS, llvm::Value *RHS, CompareKind Kind, const char *NameSuffix="")
Definition: CGExprAgg.cpp:921
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2811
void ErrorUnsupported(const Stmt *S, const char *Type)
ErrorUnsupported - Print out an error that codegen doesn&#39;t support the specified stmt yet...
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g., it is an signed integer type or a vector.
Definition: Type.cpp:1961
Represents a C++ struct/union/class.
Definition: DeclCXX.h:255
Represents a loop initializing the elements of an array.
Definition: Expr.h:4999
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:4102
llvm::Type * ConvertType(QualType T)
LValue EmitLValue(const Expr *E)
EmitLValue - Emit code to compute a designator that specifies the location of the expression...
Definition: CGExpr.cpp:1243
const ValueInfo * getEqualOrEquiv() const
CharUnits getNonVirtualSize() const
getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...
Definition: RecordLayout.h:202
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:60
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1686
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2521
void finalize(llvm::GlobalVariable *global)
CGCXXABI & getCXXABI() const
bool hasVolatileMember(QualType T)
hasVolatileMember - returns true if aggregate type has a volatile member.
void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy, AggValueSlot::Overlap_t MayOverlap, bool isVolatile=false)
EmitAggregateCopy - Emit an aggregate copy.
Definition: CGExprAgg.cpp:1914
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument for this lambda expression...
Definition: ExprCXX.h:1975
A rewritten comparison expression that was originally written using operator syntax.
Definition: ExprCXX.h:273
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1146
static RValue get(llvm::Value *V)
Definition: CGValue.h:85
bool isUnion() const
Definition: Decl.h:3321
Expr * getRHS() const
Definition: Expr.h:3451
Expr *const * const_capture_init_iterator
Const iterator that walks over the capture initialization arguments.
Definition: ExprCXX.h:1949
bool isPointerType() const
Definition: Type.h:6391
bool hasObjectMember() const
Definition: Decl.h:3743
void EmitLifetimeEnd(llvm::Value *Size, llvm::Value *Addr)
Definition: CGDecl.cpp:1302
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:4487
QualType getType() const
Definition: Decl.h:655
static RValue getAggregate(Address addr, bool isVolatile=false)
Definition: CGValue.h:106
LValue - This represents an lvalue references.
Definition: CGValue.h:166
RValue asRValue() const
Definition: CGValue.h:606
const LangOptions & getLangOpts() const
unsigned getTargetAddressSpace(QualType T) const
Definition: ASTContext.h:2541
const ValueInfo * getUnordered() const
llvm::APInt getArraySize() const
Definition: Expr.h:5023
llvm::Value * getPointer() const
Definition: CGValue.h:322
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2906
bool isZeroInitializable(QualType T)
IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:5089
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
bool isScalar() const
Definition: CGValue.h:51
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:2278
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2962
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
ComparisonCategories CompCategories
Types and expressions required to build C++2a three-way comparisons using operator<=>, including the values return by builtin <=> operators.
Definition: ASTContext.h:2039