clang  3.9.0
CGExprAgg.cpp
Go to the documentation of this file.
1 //===--- CGExprAgg.cpp - Emit LLVM Code from Aggregate Expressions --------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This contains code to emit Aggregate Expr nodes as LLVM code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenFunction.h"
15 #include "CGObjCRuntime.h"
16 #include "CodeGenModule.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/DeclCXX.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/StmtVisitor.h"
21 #include "llvm/IR/Constants.h"
22 #include "llvm/IR/Function.h"
23 #include "llvm/IR/GlobalVariable.h"
24 #include "llvm/IR/Intrinsics.h"
25 using namespace clang;
26 using namespace CodeGen;
27 
28 //===----------------------------------------------------------------------===//
29 // Aggregate Expression Emitter
30 //===----------------------------------------------------------------------===//
31 
32 namespace {
33 class AggExprEmitter : public StmtVisitor<AggExprEmitter> {
34  CodeGenFunction &CGF;
36  AggValueSlot Dest;
37  bool IsResultUnused;
38 
39  /// We want to use 'dest' as the return slot except under two
40  /// conditions:
41  /// - The destination slot requires garbage collection, so we
42  /// need to use the GC API.
43  /// - The destination slot is potentially aliased.
44  bool shouldUseDestForReturnSlot() const {
45  return !(Dest.requiresGCollection() || Dest.isPotentiallyAliased());
46  }
47 
48  ReturnValueSlot getReturnValueSlot() const {
49  if (!shouldUseDestForReturnSlot())
50  return ReturnValueSlot();
51 
52  return ReturnValueSlot(Dest.getAddress(), Dest.isVolatile(),
53  IsResultUnused);
54  }
55 
56  AggValueSlot EnsureSlot(QualType T) {
57  if (!Dest.isIgnored()) return Dest;
58  return CGF.CreateAggTemp(T, "agg.tmp.ensured");
59  }
60  void EnsureDest(QualType T) {
61  if (!Dest.isIgnored()) return;
62  Dest = CGF.CreateAggTemp(T, "agg.tmp.ensured");
63  }
64 
65 public:
66  AggExprEmitter(CodeGenFunction &cgf, AggValueSlot Dest, bool IsResultUnused)
67  : CGF(cgf), Builder(CGF.Builder), Dest(Dest),
68  IsResultUnused(IsResultUnused) { }
69 
70  //===--------------------------------------------------------------------===//
71  // Utilities
72  //===--------------------------------------------------------------------===//
73 
74  /// EmitAggLoadOfLValue - Given an expression with aggregate type that
75  /// represents a value lvalue, this method emits the address of the lvalue,
76  /// then loads the result into DestPtr.
77  void EmitAggLoadOfLValue(const Expr *E);
78 
79  /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
80  void EmitFinalDestCopy(QualType type, const LValue &src);
81  void EmitFinalDestCopy(QualType type, RValue src);
82  void EmitCopy(QualType type, const AggValueSlot &dest,
83  const AggValueSlot &src);
84 
85  void EmitMoveFromReturnSlot(const Expr *E, RValue Src);
86 
87  void EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,
88  QualType elementType, InitListExpr *E);
89 
91  if (CGF.getLangOpts().getGC() && TypeRequiresGCollection(T))
94  }
95 
96  bool TypeRequiresGCollection(QualType T);
97 
98  //===--------------------------------------------------------------------===//
99  // Visitor Methods
100  //===--------------------------------------------------------------------===//
101 
102  void Visit(Expr *E) {
103  ApplyDebugLocation DL(CGF, E);
105  }
106 
107  void VisitStmt(Stmt *S) {
108  CGF.ErrorUnsupported(S, "aggregate expression");
109  }
110  void VisitParenExpr(ParenExpr *PE) { Visit(PE->getSubExpr()); }
111  void VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
112  Visit(GE->getResultExpr());
113  }
114  void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
115  void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
116  return Visit(E->getReplacement());
117  }
118 
119  // l-values.
120  void VisitDeclRefExpr(DeclRefExpr *E) {
121  // For aggregates, we should always be able to emit the variable
122  // as an l-value unless it's a reference. This is due to the fact
123  // that we can't actually ever see a normal l2r conversion on an
124  // aggregate in C++, and in C there's no language standard
125  // actively preventing us from listing variables in the captures
126  // list of a block.
127  if (E->getDecl()->getType()->isReferenceType()) {
129  = CGF.tryEmitAsConstant(E)) {
130  EmitFinalDestCopy(E->getType(), result.getReferenceLValue(CGF, E));
131  return;
132  }
133  }
134 
135  EmitAggLoadOfLValue(E);
136  }
137 
138  void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }
139  void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
140  void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }
141  void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
142  void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
143  EmitAggLoadOfLValue(E);
144  }
145  void VisitPredefinedExpr(const PredefinedExpr *E) {
146  EmitAggLoadOfLValue(E);
147  }
148 
149  // Operators.
150  void VisitCastExpr(CastExpr *E);
151  void VisitCallExpr(const CallExpr *E);
152  void VisitStmtExpr(const StmtExpr *E);
153  void VisitBinaryOperator(const BinaryOperator *BO);
154  void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO);
155  void VisitBinAssign(const BinaryOperator *E);
156  void VisitBinComma(const BinaryOperator *E);
157 
158  void VisitObjCMessageExpr(ObjCMessageExpr *E);
159  void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
160  EmitAggLoadOfLValue(E);
161  }
162 
163  void VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E);
164  void VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
165  void VisitChooseExpr(const ChooseExpr *CE);
166  void VisitInitListExpr(InitListExpr *E);
167  void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
168  void VisitNoInitExpr(NoInitExpr *E) { } // Do nothing.
169  void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
170  Visit(DAE->getExpr());
171  }
172  void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
174  Visit(DIE->getExpr());
175  }
176  void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
177  void VisitCXXConstructExpr(const CXXConstructExpr *E);
178  void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
179  void VisitLambdaExpr(LambdaExpr *E);
180  void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
181  void VisitExprWithCleanups(ExprWithCleanups *E);
182  void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
183  void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); }
184  void VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
185  void VisitOpaqueValueExpr(OpaqueValueExpr *E);
186 
187  void VisitPseudoObjectExpr(PseudoObjectExpr *E) {
188  if (E->isGLValue()) {
189  LValue LV = CGF.EmitPseudoObjectLValue(E);
190  return EmitFinalDestCopy(E->getType(), LV);
191  }
192 
193  CGF.EmitPseudoObjectRValue(E, EnsureSlot(E->getType()));
194  }
195 
196  void VisitVAArgExpr(VAArgExpr *E);
197 
198  void EmitInitializationToLValue(Expr *E, LValue Address);
199  void EmitNullInitializationToLValue(LValue Address);
200  // case Expr::ChooseExprClass:
201  void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
202  void VisitAtomicExpr(AtomicExpr *E) {
203  RValue Res = CGF.EmitAtomicExpr(E);
204  EmitFinalDestCopy(E->getType(), Res);
205  }
206 };
207 } // end anonymous namespace.
208 
209 //===----------------------------------------------------------------------===//
210 // Utilities
211 //===----------------------------------------------------------------------===//
212 
213 /// EmitAggLoadOfLValue - Given an expression with aggregate type that
214 /// represents a value lvalue, this method emits the address of the lvalue,
215 /// then loads the result into DestPtr.
216 void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
217  LValue LV = CGF.EmitLValue(E);
218 
219  // If the type of the l-value is atomic, then do an atomic load.
220  if (LV.getType()->isAtomicType() || CGF.LValueIsSuitableForInlineAtomic(LV)) {
221  CGF.EmitAtomicLoad(LV, E->getExprLoc(), Dest);
222  return;
223  }
224 
225  EmitFinalDestCopy(E->getType(), LV);
226 }
227 
228 /// \brief True if the given aggregate type requires special GC API calls.
229 bool AggExprEmitter::TypeRequiresGCollection(QualType T) {
230  // Only record types have members that might require garbage collection.
231  const RecordType *RecordTy = T->getAs<RecordType>();
232  if (!RecordTy) return false;
233 
234  // Don't mess with non-trivial C++ types.
235  RecordDecl *Record = RecordTy->getDecl();
236  if (isa<CXXRecordDecl>(Record) &&
237  (cast<CXXRecordDecl>(Record)->hasNonTrivialCopyConstructor() ||
238  !cast<CXXRecordDecl>(Record)->hasTrivialDestructor()))
239  return false;
240 
241  // Check whether the type has an object member.
242  return Record->hasObjectMember();
243 }
244 
245 /// \brief Perform the final move to DestPtr if for some reason
246 /// getReturnValueSlot() didn't use it directly.
247 ///
248 /// The idea is that you do something like this:
249 /// RValue Result = EmitSomething(..., getReturnValueSlot());
250 /// EmitMoveFromReturnSlot(E, Result);
251 ///
252 /// If nothing interferes, this will cause the result to be emitted
253 /// directly into the return value slot. Otherwise, a final move
254 /// will be performed.
255 void AggExprEmitter::EmitMoveFromReturnSlot(const Expr *E, RValue src) {
256  if (shouldUseDestForReturnSlot()) {
257  // Logically, Dest.getAddr() should equal Src.getAggregateAddr().
258  // The possibility of undef rvalues complicates that a lot,
259  // though, so we can't really assert.
260  return;
261  }
262 
263  // Otherwise, copy from there to the destination.
264  assert(Dest.getPointer() != src.getAggregatePointer());
265  EmitFinalDestCopy(E->getType(), src);
266 }
267 
268 /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
269 void AggExprEmitter::EmitFinalDestCopy(QualType type, RValue src) {
270  assert(src.isAggregate() && "value must be aggregate value!");
271  LValue srcLV = CGF.MakeAddrLValue(src.getAggregateAddress(), type);
272  EmitFinalDestCopy(type, srcLV);
273 }
274 
275 /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
276 void AggExprEmitter::EmitFinalDestCopy(QualType type, const LValue &src) {
277  // If Dest is ignored, then we're evaluating an aggregate expression
278  // in a context that doesn't care about the result. Note that loads
279  // from volatile l-values force the existence of a non-ignored
280  // destination.
281  if (Dest.isIgnored())
282  return;
283 
284  AggValueSlot srcAgg =
286  needsGC(type), AggValueSlot::IsAliased);
287  EmitCopy(type, Dest, srcAgg);
288 }
289 
290 /// Perform a copy from the source into the destination.
291 ///
292 /// \param type - the type of the aggregate being copied; qualifiers are
293 /// ignored
294 void AggExprEmitter::EmitCopy(QualType type, const AggValueSlot &dest,
295  const AggValueSlot &src) {
296  if (dest.requiresGCollection()) {
297  CharUnits sz = CGF.getContext().getTypeSizeInChars(type);
298  llvm::Value *size = llvm::ConstantInt::get(CGF.SizeTy, sz.getQuantity());
299  CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF,
300  dest.getAddress(),
301  src.getAddress(),
302  size);
303  return;
304  }
305 
306  // If the result of the assignment is used, copy the LHS there also.
307  // It's volatile if either side is. Use the minimum alignment of
308  // the two sides.
309  CGF.EmitAggregateCopy(dest.getAddress(), src.getAddress(), type,
310  dest.isVolatile() || src.isVolatile());
311 }
312 
313 /// \brief Emit the initializer for a std::initializer_list initialized with a
314 /// real initializer list.
315 void
316 AggExprEmitter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
317  // Emit an array containing the elements. The array is externally destructed
318  // if the std::initializer_list object is.
319  ASTContext &Ctx = CGF.getContext();
320  LValue Array = CGF.EmitLValue(E->getSubExpr());
321  assert(Array.isSimple() && "initializer_list array not a simple lvalue");
322  Address ArrayPtr = Array.getAddress();
323 
326  assert(ArrayType && "std::initializer_list constructed from non-array");
327 
328  // FIXME: Perform the checks on the field types in SemaInit.
329  RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
331  if (Field == Record->field_end()) {
332  CGF.ErrorUnsupported(E, "weird std::initializer_list");
333  return;
334  }
335 
336  // Start pointer.
337  if (!Field->getType()->isPointerType() ||
338  !Ctx.hasSameType(Field->getType()->getPointeeType(),
339  ArrayType->getElementType())) {
340  CGF.ErrorUnsupported(E, "weird std::initializer_list");
341  return;
342  }
343 
344  AggValueSlot Dest = EnsureSlot(E->getType());
345  LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
346  LValue Start = CGF.EmitLValueForFieldInitialization(DestLV, *Field);
347  llvm::Value *Zero = llvm::ConstantInt::get(CGF.PtrDiffTy, 0);
348  llvm::Value *IdxStart[] = { Zero, Zero };
349  llvm::Value *ArrayStart =
350  Builder.CreateInBoundsGEP(ArrayPtr.getPointer(), IdxStart, "arraystart");
351  CGF.EmitStoreThroughLValue(RValue::get(ArrayStart), Start);
352  ++Field;
353 
354  if (Field == Record->field_end()) {
355  CGF.ErrorUnsupported(E, "weird std::initializer_list");
356  return;
357  }
358 
359  llvm::Value *Size = Builder.getInt(ArrayType->getSize());
360  LValue EndOrLength = CGF.EmitLValueForFieldInitialization(DestLV, *Field);
361  if (Field->getType()->isPointerType() &&
362  Ctx.hasSameType(Field->getType()->getPointeeType(),
363  ArrayType->getElementType())) {
364  // End pointer.
365  llvm::Value *IdxEnd[] = { Zero, Size };
366  llvm::Value *ArrayEnd =
367  Builder.CreateInBoundsGEP(ArrayPtr.getPointer(), IdxEnd, "arrayend");
368  CGF.EmitStoreThroughLValue(RValue::get(ArrayEnd), EndOrLength);
369  } else if (Ctx.hasSameType(Field->getType(), Ctx.getSizeType())) {
370  // Length.
371  CGF.EmitStoreThroughLValue(RValue::get(Size), EndOrLength);
372  } else {
373  CGF.ErrorUnsupported(E, "weird std::initializer_list");
374  return;
375  }
376 }
377 
378 /// \brief Determine if E is a trivial array filler, that is, one that is
379 /// equivalent to zero-initialization.
380 static bool isTrivialFiller(Expr *E) {
381  if (!E)
382  return true;
383 
384  if (isa<ImplicitValueInitExpr>(E))
385  return true;
386 
387  if (auto *ILE = dyn_cast<InitListExpr>(E)) {
388  if (ILE->getNumInits())
389  return false;
390  return isTrivialFiller(ILE->getArrayFiller());
391  }
392 
393  if (auto *Cons = dyn_cast_or_null<CXXConstructExpr>(E))
394  return Cons->getConstructor()->isDefaultConstructor() &&
395  Cons->getConstructor()->isTrivial();
396 
397  // FIXME: Are there other cases where we can avoid emitting an initializer?
398  return false;
399 }
400 
401 /// \brief Emit initialization of an array from an initializer list.
402 void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,
403  QualType elementType, InitListExpr *E) {
404  uint64_t NumInitElements = E->getNumInits();
405 
406  uint64_t NumArrayElements = AType->getNumElements();
407  assert(NumInitElements <= NumArrayElements);
408 
409  // DestPtr is an array*. Construct an elementType* by drilling
410  // down a level.
411  llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
412  llvm::Value *indices[] = { zero, zero };
413  llvm::Value *begin =
414  Builder.CreateInBoundsGEP(DestPtr.getPointer(), indices, "arrayinit.begin");
415 
416  CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
417  CharUnits elementAlign =
418  DestPtr.getAlignment().alignmentOfArrayElement(elementSize);
419 
420  // Exception safety requires us to destroy all the
421  // already-constructed members if an initializer throws.
422  // For that, we'll need an EH cleanup.
423  QualType::DestructionKind dtorKind = elementType.isDestructedType();
424  Address endOfInit = Address::invalid();
426  llvm::Instruction *cleanupDominator = nullptr;
427  if (CGF.needsEHCleanup(dtorKind)) {
428  // In principle we could tell the cleanup where we are more
429  // directly, but the control flow can get so varied here that it
430  // would actually be quite complex. Therefore we go through an
431  // alloca.
432  endOfInit = CGF.CreateTempAlloca(begin->getType(), CGF.getPointerAlign(),
433  "arrayinit.endOfInit");
434  cleanupDominator = Builder.CreateStore(begin, endOfInit);
435  CGF.pushIrregularPartialArrayCleanup(begin, endOfInit, elementType,
436  elementAlign,
437  CGF.getDestroyer(dtorKind));
438  cleanup = CGF.EHStack.stable_begin();
439 
440  // Otherwise, remember that we didn't need a cleanup.
441  } else {
442  dtorKind = QualType::DK_none;
443  }
444 
445  llvm::Value *one = llvm::ConstantInt::get(CGF.SizeTy, 1);
446 
447  // The 'current element to initialize'. The invariants on this
448  // variable are complicated. Essentially, after each iteration of
449  // the loop, it points to the last initialized element, except
450  // that it points to the beginning of the array before any
451  // elements have been initialized.
452  llvm::Value *element = begin;
453 
454  // Emit the explicit initializers.
455  for (uint64_t i = 0; i != NumInitElements; ++i) {
456  // Advance to the next element.
457  if (i > 0) {
458  element = Builder.CreateInBoundsGEP(element, one, "arrayinit.element");
459 
460  // Tell the cleanup that it needs to destroy up to this
461  // element. TODO: some of these stores can be trivially
462  // observed to be unnecessary.
463  if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit);
464  }
465 
466  LValue elementLV =
467  CGF.MakeAddrLValue(Address(element, elementAlign), elementType);
468  EmitInitializationToLValue(E->getInit(i), elementLV);
469  }
470 
471  // Check whether there's a non-trivial array-fill expression.
472  Expr *filler = E->getArrayFiller();
473  bool hasTrivialFiller = isTrivialFiller(filler);
474 
475  // Any remaining elements need to be zero-initialized, possibly
476  // using the filler expression. We can skip this if the we're
477  // emitting to zeroed memory.
478  if (NumInitElements != NumArrayElements &&
479  !(Dest.isZeroed() && hasTrivialFiller &&
480  CGF.getTypes().isZeroInitializable(elementType))) {
481 
482  // Use an actual loop. This is basically
483  // do { *array++ = filler; } while (array != end);
484 
485  // Advance to the start of the rest of the array.
486  if (NumInitElements) {
487  element = Builder.CreateInBoundsGEP(element, one, "arrayinit.start");
488  if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit);
489  }
490 
491  // Compute the end of the array.
492  llvm::Value *end = Builder.CreateInBoundsGEP(begin,
493  llvm::ConstantInt::get(CGF.SizeTy, NumArrayElements),
494  "arrayinit.end");
495 
496  llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
497  llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body");
498 
499  // Jump into the body.
500  CGF.EmitBlock(bodyBB);
501  llvm::PHINode *currentElement =
502  Builder.CreatePHI(element->getType(), 2, "arrayinit.cur");
503  currentElement->addIncoming(element, entryBB);
504 
505  // Emit the actual filler expression.
506  LValue elementLV =
507  CGF.MakeAddrLValue(Address(currentElement, elementAlign), elementType);
508  if (filler)
509  EmitInitializationToLValue(filler, elementLV);
510  else
511  EmitNullInitializationToLValue(elementLV);
512 
513  // Move on to the next element.
514  llvm::Value *nextElement =
515  Builder.CreateInBoundsGEP(currentElement, one, "arrayinit.next");
516 
517  // Tell the EH cleanup that we finished with the last element.
518  if (endOfInit.isValid()) Builder.CreateStore(nextElement, endOfInit);
519 
520  // Leave the loop if we're done.
521  llvm::Value *done = Builder.CreateICmpEQ(nextElement, end,
522  "arrayinit.done");
523  llvm::BasicBlock *endBB = CGF.createBasicBlock("arrayinit.end");
524  Builder.CreateCondBr(done, endBB, bodyBB);
525  currentElement->addIncoming(nextElement, Builder.GetInsertBlock());
526 
527  CGF.EmitBlock(endBB);
528  }
529 
530  // Leave the partial-array cleanup if we entered one.
531  if (dtorKind) CGF.DeactivateCleanupBlock(cleanup, cleanupDominator);
532 }
533 
534 //===----------------------------------------------------------------------===//
535 // Visitor Methods
536 //===----------------------------------------------------------------------===//
537 
538 void AggExprEmitter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E){
539  Visit(E->GetTemporaryExpr());
540 }
541 
542 void AggExprEmitter::VisitOpaqueValueExpr(OpaqueValueExpr *e) {
543  EmitFinalDestCopy(e->getType(), CGF.getOpaqueLValueMapping(e));
544 }
545 
546 void
547 AggExprEmitter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
548  if (Dest.isPotentiallyAliased() &&
549  E->getType().isPODType(CGF.getContext())) {
550  // For a POD type, just emit a load of the lvalue + a copy, because our
551  // compound literal might alias the destination.
552  EmitAggLoadOfLValue(E);
553  return;
554  }
555 
556  AggValueSlot Slot = EnsureSlot(E->getType());
557  CGF.EmitAggExpr(E->getInitializer(), Slot);
558 }
559 
560 /// Attempt to look through various unimportant expressions to find a
561 /// cast of the given kind.
563  while (true) {
564  op = op->IgnoreParens();
565  if (CastExpr *castE = dyn_cast<CastExpr>(op)) {
566  if (castE->getCastKind() == kind)
567  return castE->getSubExpr();
568  if (castE->getCastKind() == CK_NoOp)
569  continue;
570  }
571  return nullptr;
572  }
573 }
574 
575 void AggExprEmitter::VisitCastExpr(CastExpr *E) {
576  if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
577  CGF.CGM.EmitExplicitCastExprType(ECE, &CGF);
578  switch (E->getCastKind()) {
579  case CK_Dynamic: {
580  // FIXME: Can this actually happen? We have no test coverage for it.
581  assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?");
582  LValue LV = CGF.EmitCheckedLValue(E->getSubExpr(),
584  // FIXME: Do we also need to handle property references here?
585  if (LV.isSimple())
586  CGF.EmitDynamicCast(LV.getAddress(), cast<CXXDynamicCastExpr>(E));
587  else
588  CGF.CGM.ErrorUnsupported(E, "non-simple lvalue dynamic_cast");
589 
590  if (!Dest.isIgnored())
591  CGF.CGM.ErrorUnsupported(E, "lvalue dynamic_cast with a destination");
592  break;
593  }
594 
595  case CK_ToUnion: {
596  // Evaluate even if the destination is ignored.
597  if (Dest.isIgnored()) {
598  CGF.EmitAnyExpr(E->getSubExpr(), AggValueSlot::ignored(),
599  /*ignoreResult=*/true);
600  break;
601  }
602 
603  // GCC union extension
604  QualType Ty = E->getSubExpr()->getType();
605  Address CastPtr =
606  Builder.CreateElementBitCast(Dest.getAddress(), CGF.ConvertType(Ty));
607  EmitInitializationToLValue(E->getSubExpr(),
608  CGF.MakeAddrLValue(CastPtr, Ty));
609  break;
610  }
611 
612  case CK_DerivedToBase:
613  case CK_BaseToDerived:
614  case CK_UncheckedDerivedToBase: {
615  llvm_unreachable("cannot perform hierarchy conversion in EmitAggExpr: "
616  "should have been unpacked before we got here");
617  }
618 
619  case CK_NonAtomicToAtomic:
620  case CK_AtomicToNonAtomic: {
621  bool isToAtomic = (E->getCastKind() == CK_NonAtomicToAtomic);
622 
623  // Determine the atomic and value types.
624  QualType atomicType = E->getSubExpr()->getType();
625  QualType valueType = E->getType();
626  if (isToAtomic) std::swap(atomicType, valueType);
627 
628  assert(atomicType->isAtomicType());
629  assert(CGF.getContext().hasSameUnqualifiedType(valueType,
630  atomicType->castAs<AtomicType>()->getValueType()));
631 
632  // Just recurse normally if we're ignoring the result or the
633  // atomic type doesn't change representation.
634  if (Dest.isIgnored() || !CGF.CGM.isPaddedAtomicType(atomicType)) {
635  return Visit(E->getSubExpr());
636  }
637 
638  CastKind peepholeTarget =
639  (isToAtomic ? CK_AtomicToNonAtomic : CK_NonAtomicToAtomic);
640 
641  // These two cases are reverses of each other; try to peephole them.
642  if (Expr *op = findPeephole(E->getSubExpr(), peepholeTarget)) {
643  assert(CGF.getContext().hasSameUnqualifiedType(op->getType(),
644  E->getType()) &&
645  "peephole significantly changed types?");
646  return Visit(op);
647  }
648 
649  // If we're converting an r-value of non-atomic type to an r-value
650  // of atomic type, just emit directly into the relevant sub-object.
651  if (isToAtomic) {
652  AggValueSlot valueDest = Dest;
653  if (!valueDest.isIgnored() && CGF.CGM.isPaddedAtomicType(atomicType)) {
654  // Zero-initialize. (Strictly speaking, we only need to intialize
655  // the padding at the end, but this is simpler.)
656  if (!Dest.isZeroed())
657  CGF.EmitNullInitialization(Dest.getAddress(), atomicType);
658 
659  // Build a GEP to refer to the subobject.
660  Address valueAddr =
661  CGF.Builder.CreateStructGEP(valueDest.getAddress(), 0,
662  CharUnits());
663  valueDest = AggValueSlot::forAddr(valueAddr,
664  valueDest.getQualifiers(),
665  valueDest.isExternallyDestructed(),
666  valueDest.requiresGCollection(),
667  valueDest.isPotentiallyAliased(),
669  }
670 
671  CGF.EmitAggExpr(E->getSubExpr(), valueDest);
672  return;
673  }
674 
675  // Otherwise, we're converting an atomic type to a non-atomic type.
676  // Make an atomic temporary, emit into that, and then copy the value out.
677  AggValueSlot atomicSlot =
678  CGF.CreateAggTemp(atomicType, "atomic-to-nonatomic.temp");
679  CGF.EmitAggExpr(E->getSubExpr(), atomicSlot);
680 
681  Address valueAddr =
682  Builder.CreateStructGEP(atomicSlot.getAddress(), 0, CharUnits());
683  RValue rvalue = RValue::getAggregate(valueAddr, atomicSlot.isVolatile());
684  return EmitFinalDestCopy(valueType, rvalue);
685  }
686 
687  case CK_LValueToRValue:
688  // If we're loading from a volatile type, force the destination
689  // into existence.
690  if (E->getSubExpr()->getType().isVolatileQualified()) {
691  EnsureDest(E->getType());
692  return Visit(E->getSubExpr());
693  }
694 
695  // fallthrough
696 
697  case CK_NoOp:
698  case CK_UserDefinedConversion:
699  case CK_ConstructorConversion:
700  assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(),
701  E->getType()) &&
702  "Implicit cast types must be compatible");
703  Visit(E->getSubExpr());
704  break;
705 
706  case CK_LValueBitCast:
707  llvm_unreachable("should not be emitting lvalue bitcast as rvalue");
708 
709  case CK_Dependent:
710  case CK_BitCast:
711  case CK_ArrayToPointerDecay:
712  case CK_FunctionToPointerDecay:
713  case CK_NullToPointer:
714  case CK_NullToMemberPointer:
715  case CK_BaseToDerivedMemberPointer:
716  case CK_DerivedToBaseMemberPointer:
717  case CK_MemberPointerToBoolean:
718  case CK_ReinterpretMemberPointer:
719  case CK_IntegralToPointer:
720  case CK_PointerToIntegral:
721  case CK_PointerToBoolean:
722  case CK_ToVoid:
723  case CK_VectorSplat:
724  case CK_IntegralCast:
725  case CK_BooleanToSignedIntegral:
726  case CK_IntegralToBoolean:
727  case CK_IntegralToFloating:
728  case CK_FloatingToIntegral:
729  case CK_FloatingToBoolean:
730  case CK_FloatingCast:
731  case CK_CPointerToObjCPointerCast:
732  case CK_BlockPointerToObjCPointerCast:
733  case CK_AnyPointerToBlockPointerCast:
734  case CK_ObjCObjectLValueCast:
735  case CK_FloatingRealToComplex:
736  case CK_FloatingComplexToReal:
737  case CK_FloatingComplexToBoolean:
738  case CK_FloatingComplexCast:
739  case CK_FloatingComplexToIntegralComplex:
740  case CK_IntegralRealToComplex:
741  case CK_IntegralComplexToReal:
742  case CK_IntegralComplexToBoolean:
743  case CK_IntegralComplexCast:
744  case CK_IntegralComplexToFloatingComplex:
745  case CK_ARCProduceObject:
746  case CK_ARCConsumeObject:
747  case CK_ARCReclaimReturnedObject:
748  case CK_ARCExtendBlockObject:
749  case CK_CopyAndAutoreleaseBlockObject:
750  case CK_BuiltinFnToFnPtr:
751  case CK_ZeroToOCLEvent:
752  case CK_AddressSpaceConversion:
753  llvm_unreachable("cast kind invalid for aggregate types");
754  }
755 }
756 
757 void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
758  if (E->getCallReturnType(CGF.getContext())->isReferenceType()) {
759  EmitAggLoadOfLValue(E);
760  return;
761  }
762 
763  RValue RV = CGF.EmitCallExpr(E, getReturnValueSlot());
764  EmitMoveFromReturnSlot(E, RV);
765 }
766 
767 void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
768  RValue RV = CGF.EmitObjCMessageExpr(E, getReturnValueSlot());
769  EmitMoveFromReturnSlot(E, RV);
770 }
771 
772 void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
773  CGF.EmitIgnoredExpr(E->getLHS());
774  Visit(E->getRHS());
775 }
776 
777 void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
779  CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest);
780 }
781 
782 void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
783  if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI)
784  VisitPointerToDataMemberBinaryOperator(E);
785  else
786  CGF.ErrorUnsupported(E, "aggregate binary expression");
787 }
788 
789 void AggExprEmitter::VisitPointerToDataMemberBinaryOperator(
790  const BinaryOperator *E) {
791  LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E);
792  EmitFinalDestCopy(E->getType(), LV);
793 }
794 
795 /// Is the value of the given expression possibly a reference to or
796 /// into a __block variable?
797 static bool isBlockVarRef(const Expr *E) {
798  // Make sure we look through parens.
799  E = E->IgnoreParens();
800 
801  // Check for a direct reference to a __block variable.
802  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
803  const VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl());
804  return (var && var->hasAttr<BlocksAttr>());
805  }
806 
807  // More complicated stuff.
808 
809  // Binary operators.
810  if (const BinaryOperator *op = dyn_cast<BinaryOperator>(E)) {
811  // For an assignment or pointer-to-member operation, just care
812  // about the LHS.
813  if (op->isAssignmentOp() || op->isPtrMemOp())
814  return isBlockVarRef(op->getLHS());
815 
816  // For a comma, just care about the RHS.
817  if (op->getOpcode() == BO_Comma)
818  return isBlockVarRef(op->getRHS());
819 
820  // FIXME: pointer arithmetic?
821  return false;
822 
823  // Check both sides of a conditional operator.
824  } else if (const AbstractConditionalOperator *op
825  = dyn_cast<AbstractConditionalOperator>(E)) {
826  return isBlockVarRef(op->getTrueExpr())
827  || isBlockVarRef(op->getFalseExpr());
828 
829  // OVEs are required to support BinaryConditionalOperators.
830  } else if (const OpaqueValueExpr *op
831  = dyn_cast<OpaqueValueExpr>(E)) {
832  if (const Expr *src = op->getSourceExpr())
833  return isBlockVarRef(src);
834 
835  // Casts are necessary to get things like (*(int*)&var) = foo().
836  // We don't really care about the kind of cast here, except
837  // we don't want to look through l2r casts, because it's okay
838  // to get the *value* in a __block variable.
839  } else if (const CastExpr *cast = dyn_cast<CastExpr>(E)) {
840  if (cast->getCastKind() == CK_LValueToRValue)
841  return false;
842  return isBlockVarRef(cast->getSubExpr());
843 
844  // Handle unary operators. Again, just aggressively look through
845  // it, ignoring the operation.
846  } else if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E)) {
847  return isBlockVarRef(uop->getSubExpr());
848 
849  // Look into the base of a field access.
850  } else if (const MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
851  return isBlockVarRef(mem->getBase());
852 
853  // Look into the base of a subscript.
854  } else if (const ArraySubscriptExpr *sub = dyn_cast<ArraySubscriptExpr>(E)) {
855  return isBlockVarRef(sub->getBase());
856  }
857 
858  return false;
859 }
860 
861 void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
862  // For an assignment to work, the value on the right has
863  // to be compatible with the value on the left.
864  assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
865  E->getRHS()->getType())
866  && "Invalid assignment");
867 
868  // If the LHS might be a __block variable, and the RHS can
869  // potentially cause a block copy, we need to evaluate the RHS first
870  // so that the assignment goes the right place.
871  // This is pretty semantically fragile.
872  if (isBlockVarRef(E->getLHS()) &&
873  E->getRHS()->HasSideEffects(CGF.getContext())) {
874  // Ensure that we have a destination, and evaluate the RHS into that.
875  EnsureDest(E->getRHS()->getType());
876  Visit(E->getRHS());
877 
878  // Now emit the LHS and copy into it.
879  LValue LHS = CGF.EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
880 
881  // That copy is an atomic copy if the LHS is atomic.
882  if (LHS.getType()->isAtomicType() ||
883  CGF.LValueIsSuitableForInlineAtomic(LHS)) {
884  CGF.EmitAtomicStore(Dest.asRValue(), LHS, /*isInit*/ false);
885  return;
886  }
887 
888  EmitCopy(E->getLHS()->getType(),
890  needsGC(E->getLHS()->getType()),
892  Dest);
893  return;
894  }
895 
896  LValue LHS = CGF.EmitLValue(E->getLHS());
897 
898  // If we have an atomic type, evaluate into the destination and then
899  // do an atomic copy.
900  if (LHS.getType()->isAtomicType() ||
901  CGF.LValueIsSuitableForInlineAtomic(LHS)) {
902  EnsureDest(E->getRHS()->getType());
903  Visit(E->getRHS());
904  CGF.EmitAtomicStore(Dest.asRValue(), LHS, /*isInit*/ false);
905  return;
906  }
907 
908  // Codegen the RHS so that it stores directly into the LHS.
909  AggValueSlot LHSSlot =
911  needsGC(E->getLHS()->getType()),
913  // A non-volatile aggregate destination might have volatile member.
914  if (!LHSSlot.isVolatile() &&
915  CGF.hasVolatileMember(E->getLHS()->getType()))
916  LHSSlot.setVolatile(true);
917 
918  CGF.EmitAggExpr(E->getRHS(), LHSSlot);
919 
920  // Copy into the destination if the assignment isn't ignored.
921  EmitFinalDestCopy(E->getType(), LHS);
922 }
923 
924 void AggExprEmitter::
925 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
926  llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
927  llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
928  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
929 
930  // Bind the common expression if necessary.
931  CodeGenFunction::OpaqueValueMapping binding(CGF, E);
932 
934  CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock,
935  CGF.getProfileCount(E));
936 
937  // Save whether the destination's lifetime is externally managed.
938  bool isExternallyDestructed = Dest.isExternallyDestructed();
939 
940  eval.begin(CGF);
941  CGF.EmitBlock(LHSBlock);
942  CGF.incrementProfileCounter(E);
943  Visit(E->getTrueExpr());
944  eval.end(CGF);
945 
946  assert(CGF.HaveInsertPoint() && "expression evaluation ended with no IP!");
947  CGF.Builder.CreateBr(ContBlock);
948 
949  // If the result of an agg expression is unused, then the emission
950  // of the LHS might need to create a destination slot. That's fine
951  // with us, and we can safely emit the RHS into the same slot, but
952  // we shouldn't claim that it's already being destructed.
953  Dest.setExternallyDestructed(isExternallyDestructed);
954 
955  eval.begin(CGF);
956  CGF.EmitBlock(RHSBlock);
957  Visit(E->getFalseExpr());
958  eval.end(CGF);
959 
960  CGF.EmitBlock(ContBlock);
961 }
962 
963 void AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) {
964  Visit(CE->getChosenSubExpr());
965 }
966 
967 void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
968  Address ArgValue = Address::invalid();
969  Address ArgPtr = CGF.EmitVAArg(VE, ArgValue);
970 
971  // If EmitVAArg fails, emit an error.
972  if (!ArgPtr.isValid()) {
973  CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
974  return;
975  }
976 
977  EmitFinalDestCopy(VE->getType(), CGF.MakeAddrLValue(ArgPtr, VE->getType()));
978 }
979 
980 void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
981  // Ensure that we have a slot, but if we already do, remember
982  // whether it was externally destructed.
983  bool wasExternallyDestructed = Dest.isExternallyDestructed();
984  EnsureDest(E->getType());
985 
986  // We're going to push a destructor if there isn't already one.
988 
989  Visit(E->getSubExpr());
990 
991  // Push that destructor we promised.
992  if (!wasExternallyDestructed)
993  CGF.EmitCXXTemporary(E->getTemporary(), E->getType(), Dest.getAddress());
994 }
995 
996 void
997 AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {
998  AggValueSlot Slot = EnsureSlot(E->getType());
999  CGF.EmitCXXConstructExpr(E, Slot);
1000 }
1001 
1002 void AggExprEmitter::VisitCXXInheritedCtorInitExpr(
1003  const CXXInheritedCtorInitExpr *E) {
1004  AggValueSlot Slot = EnsureSlot(E->getType());
1005  CGF.EmitInheritedCXXConstructorCall(
1006  E->getConstructor(), E->constructsVBase(), Slot.getAddress(),
1007  E->inheritedFromVBase(), E);
1008 }
1009 
1010 void
1011 AggExprEmitter::VisitLambdaExpr(LambdaExpr *E) {
1012  AggValueSlot Slot = EnsureSlot(E->getType());
1013  CGF.EmitLambdaExpr(E, Slot);
1014 }
1015 
1016 void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
1017  CGF.enterFullExpression(E);
1018  CodeGenFunction::RunCleanupsScope cleanups(CGF);
1019  Visit(E->getSubExpr());
1020 }
1021 
1022 void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1023  QualType T = E->getType();
1024  AggValueSlot Slot = EnsureSlot(T);
1025  EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T));
1026 }
1027 
1028 void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1029  QualType T = E->getType();
1030  AggValueSlot Slot = EnsureSlot(T);
1031  EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T));
1032 }
1033 
1034 /// isSimpleZero - If emitting this value will obviously just cause a store of
1035 /// zero to memory, return true. This can return false if uncertain, so it just
1036 /// handles simple cases.
1037 static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {
1038  E = E->IgnoreParens();
1039 
1040  // 0
1041  if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
1042  return IL->getValue() == 0;
1043  // +0.0
1044  if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E))
1045  return FL->getValue().isPosZero();
1046  // int()
1047  if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) &&
1048  CGF.getTypes().isZeroInitializable(E->getType()))
1049  return true;
1050  // (int*)0 - Null pointer expressions.
1051  if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
1052  return ICE->getCastKind() == CK_NullToPointer;
1053  // '\0'
1054  if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E))
1055  return CL->getValue() == 0;
1056 
1057  // Otherwise, hard case: conservatively return false.
1058  return false;
1059 }
1060 
1061 
1062 void
1063 AggExprEmitter::EmitInitializationToLValue(Expr *E, LValue LV) {
1064  QualType type = LV.getType();
1065  // FIXME: Ignore result?
1066  // FIXME: Are initializers affected by volatile?
1067  if (Dest.isZeroed() && isSimpleZero(E, CGF)) {
1068  // Storing "i32 0" to a zero'd memory location is a noop.
1069  return;
1070  } else if (isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) {
1071  return EmitNullInitializationToLValue(LV);
1072  } else if (isa<NoInitExpr>(E)) {
1073  // Do nothing.
1074  return;
1075  } else if (type->isReferenceType()) {
1076  RValue RV = CGF.EmitReferenceBindingToExpr(E);
1077  return CGF.EmitStoreThroughLValue(RV, LV);
1078  }
1079 
1080  switch (CGF.getEvaluationKind(type)) {
1081  case TEK_Complex:
1082  CGF.EmitComplexExprIntoLValue(E, LV, /*isInit*/ true);
1083  return;
1084  case TEK_Aggregate:
1085  CGF.EmitAggExpr(E, AggValueSlot::forLValue(LV,
1089  Dest.isZeroed()));
1090  return;
1091  case TEK_Scalar:
1092  if (LV.isSimple()) {
1093  CGF.EmitScalarInit(E, /*D=*/nullptr, LV, /*Captured=*/false);
1094  } else {
1095  CGF.EmitStoreThroughLValue(RValue::get(CGF.EmitScalarExpr(E)), LV);
1096  }
1097  return;
1098  }
1099  llvm_unreachable("bad evaluation kind");
1100 }
1101 
1102 void AggExprEmitter::EmitNullInitializationToLValue(LValue lv) {
1103  QualType type = lv.getType();
1104 
1105  // If the destination slot is already zeroed out before the aggregate is
1106  // copied into it, we don't have to emit any zeros here.
1107  if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(type))
1108  return;
1109 
1110  if (CGF.hasScalarEvaluationKind(type)) {
1111  // For non-aggregates, we can store the appropriate null constant.
1112  llvm::Value *null = CGF.CGM.EmitNullConstant(type);
1113  // Note that the following is not equivalent to
1114  // EmitStoreThroughBitfieldLValue for ARC types.
1115  if (lv.isBitField()) {
1116  CGF.EmitStoreThroughBitfieldLValue(RValue::get(null), lv);
1117  } else {
1118  assert(lv.isSimple());
1119  CGF.EmitStoreOfScalar(null, lv, /* isInitialization */ true);
1120  }
1121  } else {
1122  // There's a potential optimization opportunity in combining
1123  // memsets; that would be easy for arrays, but relatively
1124  // difficult for structures with the current code.
1125  CGF.EmitNullInitialization(lv.getAddress(), lv.getType());
1126  }
1127 }
1128 
1129 void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
1130 #if 0
1131  // FIXME: Assess perf here? Figure out what cases are worth optimizing here
1132  // (Length of globals? Chunks of zeroed-out space?).
1133  //
1134  // If we can, prefer a copy from a global; this is a lot less code for long
1135  // globals, and it's easier for the current optimizers to analyze.
1136  if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) {
1137  llvm::GlobalVariable* GV =
1138  new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true,
1140  EmitFinalDestCopy(E->getType(), CGF.MakeAddrLValue(GV, E->getType()));
1141  return;
1142  }
1143 #endif
1144  if (E->hadArrayRangeDesignator())
1145  CGF.ErrorUnsupported(E, "GNU array range designator extension");
1146 
1147  AggValueSlot Dest = EnsureSlot(E->getType());
1148 
1149  LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1150 
1151  // Handle initialization of an array.
1152  if (E->getType()->isArrayType()) {
1153  if (E->isStringLiteralInit())
1154  return Visit(E->getInit(0));
1155 
1156  QualType elementType =
1157  CGF.getContext().getAsArrayType(E->getType())->getElementType();
1158 
1159  auto AType = cast<llvm::ArrayType>(Dest.getAddress().getElementType());
1160  EmitArrayInit(Dest.getAddress(), AType, elementType, E);
1161  return;
1162  }
1163 
1164  if (E->getType()->isAtomicType()) {
1165  // An _Atomic(T) object can be list-initialized from an expression
1166  // of the same type.
1167  assert(E->getNumInits() == 1 &&
1168  CGF.getContext().hasSameUnqualifiedType(E->getInit(0)->getType(),
1169  E->getType()) &&
1170  "unexpected list initialization for atomic object");
1171  return Visit(E->getInit(0));
1172  }
1173 
1174  assert(E->getType()->isRecordType() && "Only support structs/unions here!");
1175 
1176  // Do struct initialization; this code just sets each individual member
1177  // to the approprate value. This makes bitfield support automatic;
1178  // the disadvantage is that the generated code is more difficult for
1179  // the optimizer, especially with bitfields.
1180  unsigned NumInitElements = E->getNumInits();
1181  RecordDecl *record = E->getType()->castAs<RecordType>()->getDecl();
1182 
1183  // We'll need to enter cleanup scopes in case any of the element
1184  // initializers throws an exception.
1186  llvm::Instruction *cleanupDominator = nullptr;
1187 
1188  unsigned curInitIndex = 0;
1189 
1190  // Emit initialization of base classes.
1191  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(record)) {
1192  assert(E->getNumInits() >= CXXRD->getNumBases() &&
1193  "missing initializer for base class");
1194  for (auto &Base : CXXRD->bases()) {
1195  assert(!Base.isVirtual() && "should not see vbases here");
1196  auto *BaseRD = Base.getType()->getAsCXXRecordDecl();
1197  Address V = CGF.GetAddressOfDirectBaseInCompleteClass(
1198  Dest.getAddress(), CXXRD, BaseRD,
1199  /*isBaseVirtual*/ false);
1200  AggValueSlot AggSlot =
1205  CGF.EmitAggExpr(E->getInit(curInitIndex++), AggSlot);
1206 
1207  if (QualType::DestructionKind dtorKind =
1208  Base.getType().isDestructedType()) {
1209  CGF.pushDestroy(dtorKind, V, Base.getType());
1210  cleanups.push_back(CGF.EHStack.stable_begin());
1211  }
1212  }
1213  }
1214 
1215  // Prepare a 'this' for CXXDefaultInitExprs.
1217 
1218  if (record->isUnion()) {
1219  // Only initialize one field of a union. The field itself is
1220  // specified by the initializer list.
1221  if (!E->getInitializedFieldInUnion()) {
1222  // Empty union; we have nothing to do.
1223 
1224 #ifndef NDEBUG
1225  // Make sure that it's really an empty and not a failure of
1226  // semantic analysis.
1227  for (const auto *Field : record->fields())
1228  assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
1229 #endif
1230  return;
1231  }
1232 
1233  // FIXME: volatility
1234  FieldDecl *Field = E->getInitializedFieldInUnion();
1235 
1236  LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestLV, Field);
1237  if (NumInitElements) {
1238  // Store the initializer into the field
1239  EmitInitializationToLValue(E->getInit(0), FieldLoc);
1240  } else {
1241  // Default-initialize to null.
1242  EmitNullInitializationToLValue(FieldLoc);
1243  }
1244 
1245  return;
1246  }
1247 
1248  // Here we iterate over the fields; this makes it simpler to both
1249  // default-initialize fields and skip over unnamed fields.
1250  for (const auto *field : record->fields()) {
1251  // We're done once we hit the flexible array member.
1252  if (field->getType()->isIncompleteArrayType())
1253  break;
1254 
1255  // Always skip anonymous bitfields.
1256  if (field->isUnnamedBitfield())
1257  continue;
1258 
1259  // We're done if we reach the end of the explicit initializers, we
1260  // have a zeroed object, and the rest of the fields are
1261  // zero-initializable.
1262  if (curInitIndex == NumInitElements && Dest.isZeroed() &&
1263  CGF.getTypes().isZeroInitializable(E->getType()))
1264  break;
1265 
1266 
1267  LValue LV = CGF.EmitLValueForFieldInitialization(DestLV, field);
1268  // We never generate write-barries for initialized fields.
1269  LV.setNonGC(true);
1270 
1271  if (curInitIndex < NumInitElements) {
1272  // Store the initializer into the field.
1273  EmitInitializationToLValue(E->getInit(curInitIndex++), LV);
1274  } else {
1275  // We're out of initalizers; default-initialize to null
1276  EmitNullInitializationToLValue(LV);
1277  }
1278 
1279  // Push a destructor if necessary.
1280  // FIXME: if we have an array of structures, all explicitly
1281  // initialized, we can end up pushing a linear number of cleanups.
1282  bool pushedCleanup = false;
1283  if (QualType::DestructionKind dtorKind
1284  = field->getType().isDestructedType()) {
1285  assert(LV.isSimple());
1286  if (CGF.needsEHCleanup(dtorKind)) {
1287  if (!cleanupDominator)
1288  cleanupDominator = CGF.Builder.CreateAlignedLoad(
1289  CGF.Int8Ty,
1290  llvm::Constant::getNullValue(CGF.Int8PtrTy),
1291  CharUnits::One()); // placeholder
1292 
1293  CGF.pushDestroy(EHCleanup, LV.getAddress(), field->getType(),
1294  CGF.getDestroyer(dtorKind), false);
1295  cleanups.push_back(CGF.EHStack.stable_begin());
1296  pushedCleanup = true;
1297  }
1298  }
1299 
1300  // If the GEP didn't get used because of a dead zero init or something
1301  // else, clean it up for -O0 builds and general tidiness.
1302  if (!pushedCleanup && LV.isSimple())
1303  if (llvm::GetElementPtrInst *GEP =
1304  dyn_cast<llvm::GetElementPtrInst>(LV.getPointer()))
1305  if (GEP->use_empty())
1306  GEP->eraseFromParent();
1307  }
1308 
1309  // Deactivate all the partial cleanups in reverse order, which
1310  // generally means popping them.
1311  for (unsigned i = cleanups.size(); i != 0; --i)
1312  CGF.DeactivateCleanupBlock(cleanups[i-1], cleanupDominator);
1313 
1314  // Destroy the placeholder if we made one.
1315  if (cleanupDominator)
1316  cleanupDominator->eraseFromParent();
1317 }
1318 
1319 void AggExprEmitter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1320  AggValueSlot Dest = EnsureSlot(E->getType());
1321 
1322  LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1323  EmitInitializationToLValue(E->getBase(), DestLV);
1324  VisitInitListExpr(E->getUpdater());
1325 }
1326 
1327 //===----------------------------------------------------------------------===//
1328 // Entry Points into this File
1329 //===----------------------------------------------------------------------===//
1330 
1331 /// GetNumNonZeroBytesInInit - Get an approximate count of the number of
1332 /// non-zero bytes that will be stored when outputting the initializer for the
1333 /// specified initializer expression.
1335  E = E->IgnoreParens();
1336 
1337  // 0 and 0.0 won't require any non-zero stores!
1338  if (isSimpleZero(E, CGF)) return CharUnits::Zero();
1339 
1340  // If this is an initlist expr, sum up the size of sizes of the (present)
1341  // elements. If this is something weird, assume the whole thing is non-zero.
1342  const InitListExpr *ILE = dyn_cast<InitListExpr>(E);
1343  if (!ILE || !CGF.getTypes().isZeroInitializable(ILE->getType()))
1344  return CGF.getContext().getTypeSizeInChars(E->getType());
1345 
1346  // InitListExprs for structs have to be handled carefully. If there are
1347  // reference members, we need to consider the size of the reference, not the
1348  // referencee. InitListExprs for unions and arrays can't have references.
1349  if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
1350  if (!RT->isUnionType()) {
1351  RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
1352  CharUnits NumNonZeroBytes = CharUnits::Zero();
1353 
1354  unsigned ILEElement = 0;
1355  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(SD))
1356  while (ILEElement != CXXRD->getNumBases())
1357  NumNonZeroBytes +=
1358  GetNumNonZeroBytesInInit(ILE->getInit(ILEElement++), CGF);
1359  for (const auto *Field : SD->fields()) {
1360  // We're done once we hit the flexible array member or run out of
1361  // InitListExpr elements.
1362  if (Field->getType()->isIncompleteArrayType() ||
1363  ILEElement == ILE->getNumInits())
1364  break;
1365  if (Field->isUnnamedBitfield())
1366  continue;
1367 
1368  const Expr *E = ILE->getInit(ILEElement++);
1369 
1370  // Reference values are always non-null and have the width of a pointer.
1371  if (Field->getType()->isReferenceType())
1372  NumNonZeroBytes += CGF.getContext().toCharUnitsFromBits(
1373  CGF.getTarget().getPointerWidth(0));
1374  else
1375  NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF);
1376  }
1377 
1378  return NumNonZeroBytes;
1379  }
1380  }
1381 
1382 
1383  CharUnits NumNonZeroBytes = CharUnits::Zero();
1384  for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
1385  NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF);
1386  return NumNonZeroBytes;
1387 }
1388 
1389 /// CheckAggExprForMemSetUse - If the initializer is large and has a lot of
1390 /// zeros in it, emit a memset and avoid storing the individual zeros.
1391 ///
1392 static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,
1393  CodeGenFunction &CGF) {
1394  // If the slot is already known to be zeroed, nothing to do. Don't mess with
1395  // volatile stores.
1396  if (Slot.isZeroed() || Slot.isVolatile() || !Slot.getAddress().isValid())
1397  return;
1398 
1399  // C++ objects with a user-declared constructor don't need zero'ing.
1400  if (CGF.getLangOpts().CPlusPlus)
1401  if (const RecordType *RT = CGF.getContext()
1402  .getBaseElementType(E->getType())->getAs<RecordType>()) {
1403  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1404  if (RD->hasUserDeclaredConstructor())
1405  return;
1406  }
1407 
1408  // If the type is 16-bytes or smaller, prefer individual stores over memset.
1409  CharUnits Size = CGF.getContext().getTypeSizeInChars(E->getType());
1410  if (Size <= CharUnits::fromQuantity(16))
1411  return;
1412 
1413  // Check to see if over 3/4 of the initializer are known to be zero. If so,
1414  // we prefer to emit memset + individual stores for the rest.
1415  CharUnits NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF);
1416  if (NumNonZeroBytes*4 > Size)
1417  return;
1418 
1419  // Okay, it seems like a good idea to use an initial memset, emit the call.
1420  llvm::Constant *SizeVal = CGF.Builder.getInt64(Size.getQuantity());
1421 
1422  Address Loc = Slot.getAddress();
1423  Loc = CGF.Builder.CreateElementBitCast(Loc, CGF.Int8Ty);
1424  CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal, false);
1425 
1426  // Tell the AggExprEmitter that the slot is known zero.
1427  Slot.setZeroed();
1428 }
1429 
1430 
1431 
1432 
1433 /// EmitAggExpr - Emit the computation of the specified expression of aggregate
1434 /// type. The result is computed into DestPtr. Note that if DestPtr is null,
1435 /// the value of the aggregate expression is not needed. If VolatileDest is
1436 /// true, DestPtr cannot be 0.
1438  assert(E && hasAggregateEvaluationKind(E->getType()) &&
1439  "Invalid aggregate expression to emit");
1440  assert((Slot.getAddress().isValid() || Slot.isIgnored()) &&
1441  "slot has bits but no address");
1442 
1443  // Optimize the slot if possible.
1444  CheckAggExprForMemSetUse(Slot, E, *this);
1445 
1446  AggExprEmitter(*this, Slot, Slot.isIgnored()).Visit(const_cast<Expr*>(E));
1447 }
1448 
1450  assert(hasAggregateEvaluationKind(E->getType()) && "Invalid argument!");
1451  Address Temp = CreateMemTemp(E->getType());
1452  LValue LV = MakeAddrLValue(Temp, E->getType());
1456  return LV;
1457 }
1458 
1460  Address SrcPtr, QualType Ty,
1461  bool isVolatile,
1462  bool isAssignment) {
1463  assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
1464 
1465  if (getLangOpts().CPlusPlus) {
1466  if (const RecordType *RT = Ty->getAs<RecordType>()) {
1467  CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
1468  assert((Record->hasTrivialCopyConstructor() ||
1469  Record->hasTrivialCopyAssignment() ||
1470  Record->hasTrivialMoveConstructor() ||
1471  Record->hasTrivialMoveAssignment() ||
1472  Record->isUnion()) &&
1473  "Trying to aggregate-copy a type without a trivial copy/move "
1474  "constructor or assignment operator");
1475  // Ignore empty classes in C++.
1476  if (Record->isEmpty())
1477  return;
1478  }
1479  }
1480 
1481  // Aggregate assignment turns into llvm.memcpy. This is almost valid per
1482  // C99 6.5.16.1p3, which states "If the value being stored in an object is
1483  // read from another object that overlaps in anyway the storage of the first
1484  // object, then the overlap shall be exact and the two objects shall have
1485  // qualified or unqualified versions of a compatible type."
1486  //
1487  // memcpy is not defined if the source and destination pointers are exactly
1488  // equal, but other compilers do this optimization, and almost every memcpy
1489  // implementation handles this case safely. If there is a libc that does not
1490  // safely handle this, we can add a target hook.
1491 
1492  // Get data size info for this aggregate. If this is an assignment,
1493  // don't copy the tail padding, because we might be assigning into a
1494  // base subobject where the tail padding is claimed. Otherwise,
1495  // copying it is fine.
1496  std::pair<CharUnits, CharUnits> TypeInfo;
1497  if (isAssignment)
1498  TypeInfo = getContext().getTypeInfoDataSizeInChars(Ty);
1499  else
1500  TypeInfo = getContext().getTypeInfoInChars(Ty);
1501 
1502  llvm::Value *SizeVal = nullptr;
1503  if (TypeInfo.first.isZero()) {
1504  // But note that getTypeInfo returns 0 for a VLA.
1505  if (auto *VAT = dyn_cast_or_null<VariableArrayType>(
1506  getContext().getAsArrayType(Ty))) {
1507  QualType BaseEltTy;
1508  SizeVal = emitArrayLength(VAT, BaseEltTy, DestPtr);
1509  TypeInfo = getContext().getTypeInfoDataSizeInChars(BaseEltTy);
1510  std::pair<CharUnits, CharUnits> LastElementTypeInfo;
1511  if (!isAssignment)
1512  LastElementTypeInfo = getContext().getTypeInfoInChars(BaseEltTy);
1513  assert(!TypeInfo.first.isZero());
1514  SizeVal = Builder.CreateNUWMul(
1515  SizeVal,
1516  llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity()));
1517  if (!isAssignment) {
1518  SizeVal = Builder.CreateNUWSub(
1519  SizeVal,
1520  llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity()));
1521  SizeVal = Builder.CreateNUWAdd(
1522  SizeVal, llvm::ConstantInt::get(
1523  SizeTy, LastElementTypeInfo.first.getQuantity()));
1524  }
1525  }
1526  }
1527  if (!SizeVal) {
1528  SizeVal = llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity());
1529  }
1530 
1531  // FIXME: If we have a volatile struct, the optimizer can remove what might
1532  // appear to be `extra' memory ops:
1533  //
1534  // volatile struct { int i; } a, b;
1535  //
1536  // int main() {
1537  // a = b;
1538  // a = b;
1539  // }
1540  //
1541  // we need to use a different call here. We use isVolatile to indicate when
1542  // either the source or the destination is volatile.
1543 
1544  DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty);
1545  SrcPtr = Builder.CreateElementBitCast(SrcPtr, Int8Ty);
1546 
1547  // Don't do any of the memmove_collectable tests if GC isn't set.
1548  if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
1549  // fall through
1550  } else if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
1551  RecordDecl *Record = RecordTy->getDecl();
1552  if (Record->hasObjectMember()) {
1553  CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
1554  SizeVal);
1555  return;
1556  }
1557  } else if (Ty->isArrayType()) {
1558  QualType BaseType = getContext().getBaseElementType(Ty);
1559  if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
1560  if (RecordTy->getDecl()->hasObjectMember()) {
1561  CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
1562  SizeVal);
1563  return;
1564  }
1565  }
1566  }
1567 
1568  auto Inst = Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, isVolatile);
1569 
1570  // Determine the metadata to describe the position of any padding in this
1571  // memcpy, as well as the TBAA tags for the members of the struct, in case
1572  // the optimizer wishes to expand it in to scalar memory operations.
1573  if (llvm::MDNode *TBAAStructTag = CGM.getTBAAStructInfo(Ty))
1574  Inst->setMetadata(llvm::LLVMContext::MD_tbaa_struct, TBAAStructTag);
1575 }
ReturnValueSlot - Contains the address where the return value of a function can be stored...
Definition: CGCall.h:151
Defines the clang::ASTContext interface.
unsigned getNumInits() const
Definition: Expr.h:3776
CastKind getCastKind() const
Definition: Expr.h:2680
tooling::Replacements cleanup(const FormatStyle &Style, SourceManager &SourceMgr, FileID ID, ArrayRef< CharSourceRange > Ranges)
Clean up any erroneous/redundant code in the given Ranges in the file ID.
Definition: Format.cpp:1639
A (possibly-)qualified type.
Definition: Type.h:598
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:1967
llvm::Value * getPointer() const
Definition: CGValue.h:327
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1032
CompoundStmt * getSubStmt()
Definition: Expr.h:3396
static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, IsZeroed_t isZeroed=IsNotZeroed)
Definition: CGValue.h:524
const TargetInfo & getTarget() const
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Expr * GetTemporaryExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue...
Definition: ExprCXX.h:4003
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
bool isRecordType() const
Definition: Type.h:5539
virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, Address DestPtr, Address SrcPtr, llvm::Value *Size)=0
llvm::MDNode * getTBAAStructInfo(QualType QTy)
Address getAddress() const
Definition: CGValue.h:331
Defines the C++ template declaration subclasses.
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1619
Represents an array type, per C99 6.7.5.2 - Array Declarators.
Definition: Type.h:2456
const Expr * getResultExpr() const
The generic selection's result expression.
Definition: Expr.h:4481
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1162
void setZeroed(bool V=true)
Definition: CGValue.h:586
const LangOptions & getLangOpts() const
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
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:2802
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:3962
const llvm::APInt & getSize() const
Definition: Type.h:2527
bool isVolatile() const
Definition: CGValue.h:542
bool hadArrayRangeDesignator() const
Definition: Expr.h:3893
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:797
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:562
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:768
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:52
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:2562
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:1037
field_iterator field_begin() const
Definition: Decl.cpp:3767
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition: ExprCXX.h:533
IsZeroed_t isZeroed() const
Definition: CGValue.h:587
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:913
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:2936
iterator begin() const
Definition: Type.h:4235
The collection of all-type qualifiers we support.
Definition: Type.h:117
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class...
Definition: DeclCXX.h:1213
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:1334
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3253
An object to manage conditionally-evaluated expressions.
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1150
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:92
bool isReferenceType() const
Definition: Type.h:5491
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2293
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:4240
An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Definition: EHScopeStack.h:81
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:1982
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
Expr * getSubExpr()
Definition: Expr.h:2684
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:380
Expr * getLHS() const
Definition: Expr.h:2943
void setNonGC(bool Value)
Definition: CGValue.h:271
Describes an C or C++ initializer list.
Definition: Expr.h:3746
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:575
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Definition: Expr.h:3588
Expr * getTrueExpr() const
Definition: Expr.h:3326
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:168
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
field_range fields() const
Definition: Decl.h:3382
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2897
RecordDecl * getDecl() const
Definition: Type.h:3716
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:270
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2632
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1119
CXXTemporary * getTemporary()
Definition: ExprCXX.h:1139
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1503
iterator end() const
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
bool isValid() const
Definition: Address.h:36
std::pair< CharUnits, CharUnits > getTypeInfoInChars(const Type *T) const
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:967
QualType getType() const
Definition: Decl.h:599
bool isUnnamedBitfield() const
Determines whether this is an unnamed bitfield.
Definition: Decl.h:2367
Checking the operand of a load. Must be suitably sized and aligned.
field_iterator field_end() const
Definition: Decl.h:3385
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource AlignSource=AlignmentSource::Type)
bool isUnion() const
Definition: Decl.h:2939
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5173
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
const Expr * getExpr() const
Get the initialization expression that will be used.
Definition: ExprCXX.h:1062
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:3655
std::pair< CharUnits, CharUnits > getTypeInfoDataSizeInChars(QualType T) const
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
Definition: ExprCXX.h:1764
llvm::Value * getPointer() const
Definition: Address.h:38
Expr - This represents one expression.
Definition: Expr.h:105
static Address invalid()
Definition: Address.h:35
bool isAggregate() const
Definition: CGValue.h:53
bool isAnyComplexType() const
Definition: Type.h:5545
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
bool isAtomicType() const
Definition: Type.h:5564
RValue asRValue() const
Definition: CGValue.h:578
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition: CharUnits.h:63
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
An RAII object to record that we're evaluating a statement expression.
Expr * getSubExpr() const
Definition: Expr.h:1695
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:860
llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:292
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1668
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:3767
ValueDecl * getDecl()
Definition: Expr.h:1017
bool isGLValue() const
Definition: Expr.h:250
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, IsZeroed_t isZeroed=IsNotZeroed)
forAddr - Make a slot for an aggregate value.
Definition: CGValue.h:502
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will call.
Definition: ExprCXX.h:1358
InitListExpr * getUpdater() const
Definition: Expr.h:4295
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:848
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1325
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:4679
bool isSimple() const
Definition: CGValue.h:246
ASTContext & getContext() const
A saved depth on the scope stack.
Definition: EHScopeStack.h:107
LValue EmitAggExprToLValue(const Expr *E)
EmitAggExprToLValue - Emit the computation of the specified expression of aggregate type into a tempo...
Definition: CGExprAgg.cpp:1449
An aggregate value slot.
Definition: CGValue.h:441
A scoped helper to set the current debug location to the specified location or preferred location of ...
Definition: CGDebugInfo.h:539
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:178
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2114
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>.
Definition: Expr.h:4804
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
Definition: CharUnits.h:197
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:1392
An aligned address.
Definition: Address.h:25
const LangOptions & getLangOpts() const
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:5849
bool hasObjectMember() const
Definition: Decl.h:3325
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3380
bool isBitField() const
Definition: CGValue.h:248
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5329
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:3831
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:193
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:1241
void setExternallyDestructed(bool destructed=true)
Definition: CGValue.h:536
Represents a C11 generic selection.
Definition: Expr.h:4413
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
Definition: Expr.cpp:1272
QualType getType() const
Definition: Expr.h:126
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:67
void setVolatile(bool flag)
Definition: CGValue.h:546
llvm::Value * getAggregatePointer() const
Definition: CGValue.h:75
const Expr * getExpr() const
Definition: ExprCXX.h:998
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1160
Address CreateMemTemp(QualType T, const Twine &Name="tmp")
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignment...
Definition: CGExpr.cpp:98
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchers.h:1983
static AggValueSlot ignored()
ignored - Returns an aggregate value slot indicating that the aggregate value is being ignored...
Definition: CGValue.h:487
A scope within which we are constructing the fields of an object which might use a CXXDefaultInitExpr...
U cast(CodeGen::Address addr)
Definition: Address.h:109
IsAliased_t isPotentiallyAliased() const
Definition: CGValue.h:574
bool hasTrivialMoveConstructor() const
Determine whether this class has a trivial move constructor (C++11 [class.copy]p12) ...
Definition: DeclCXX.h:1226
Checking the destination of a store. Must be suitably sized and aligned.
detail::InMemoryDirectory::const_iterator E
void EmitAggregateCopy(Address DestPtr, Address SrcPtr, QualType EltTy, bool isVolatile=false, bool isAssignment=false)
EmitAggregateCopy - Emit an aggregate copy.
Definition: CGExprAgg.cpp:1459
IsDestructed_t isExternallyDestructed() const
Definition: CGValue.h:533
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:1473
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type. ...
Definition: CGExprAgg.cpp:1437
static bool hasAggregateEvaluationKind(QualType T)
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1254
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:44
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3707
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5818
Expr * getFalseExpr() const
Definition: Expr.h:3332
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2063
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Definition: Expr.h:3128
NeedsGCBarriers_t requiresGCollection() const
Definition: CGValue.h:554
Address getAddress() const
Definition: CGValue.h:562
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
bool inheritedFromVBase() const
Determine whether the inherited constructor is inherited from a virtual base of the object we constru...
Definition: ExprCXX.h:1372
const Expr * getInitializer() const
Definition: Expr.h:2588
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:479
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1037
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:2315
const Expr * getSubExpr() const
Definition: Expr.h:1635
Represents a C++ struct/union/class.
Definition: DeclCXX.h:263
BoundNodesTreeBuilder *const Builder
Opcode getOpcode() const
Definition: Expr.h:2940
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:3547
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:43
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
Definition: CGValue.h:70
bool isArrayType() const
Definition: Type.h:5521
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1466
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2148
Expr * getRHS() const
Definition: Expr.h:2945
QualType getType() const
Definition: CGValue.h:258
bool constructsVBase() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
Definition: ExprCXX.h:1362
bool isIncompleteArrayType() const
Definition: Type.h:5527
bool isStringLiteralInit() const
Definition: Expr.cpp:1819
Expr * getBase() const
Definition: Expr.h:4292
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:932
static RValue get(llvm::Value *V)
Definition: CGValue.h:85
QualType getElementType() const
Definition: Type.h:2490
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3785
const Expr * getSubExpr() const
Definition: ExprCXX.h:1143
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:3849
static RValue getAggregate(Address addr, bool isVolatile=false)
Definition: CGValue.h:106
CodeGenTypes & getTypes() const
LValue - This represents an lvalue references.
Definition: CGValue.h:152
Qualifiers getQualifiers() const
Definition: CGValue.h:540
llvm::Value * emitArrayLength(const ArrayType *arrayType, QualType &baseType, Address &addr)
emitArrayLength - Compute the length of an array, even if it's a VLA, and drill down to the base elem...
bool isIgnored() const
Definition: CGValue.h:566
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2512
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
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:4315
bool hasUserDeclaredConstructor() const
Determine whether this class has any user-declared constructors.
Definition: DeclCXX.h:844
Expr * IgnoreParens() LLVM_READONLY
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2295