clang  6.0.0svn
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;
35  CGBuilderTy &Builder;
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 VisitCoawaitExpr(CoawaitExpr *E) {
115  CGF.EmitCoawaitExpr(*E, Dest, IsResultUnused);
116  }
117  void VisitCoyieldExpr(CoyieldExpr *E) {
118  CGF.EmitCoyieldExpr(*E, Dest, IsResultUnused);
119  }
120  void VisitUnaryCoawait(UnaryOperator *E) { Visit(E->getSubExpr()); }
121  void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
122  void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
123  return Visit(E->getReplacement());
124  }
125 
126  // l-values.
127  void VisitDeclRefExpr(DeclRefExpr *E) { EmitAggLoadOfLValue(E); }
128  void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }
129  void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
130  void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }
131  void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
132  void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
133  EmitAggLoadOfLValue(E);
134  }
135  void VisitPredefinedExpr(const PredefinedExpr *E) {
136  EmitAggLoadOfLValue(E);
137  }
138 
139  // Operators.
140  void VisitCastExpr(CastExpr *E);
141  void VisitCallExpr(const CallExpr *E);
142  void VisitStmtExpr(const StmtExpr *E);
143  void VisitBinaryOperator(const BinaryOperator *BO);
144  void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO);
145  void VisitBinAssign(const BinaryOperator *E);
146  void VisitBinComma(const BinaryOperator *E);
147 
148  void VisitObjCMessageExpr(ObjCMessageExpr *E);
149  void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
150  EmitAggLoadOfLValue(E);
151  }
152 
153  void VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E);
154  void VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
155  void VisitChooseExpr(const ChooseExpr *CE);
156  void VisitInitListExpr(InitListExpr *E);
157  void VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E,
158  llvm::Value *outerBegin = nullptr);
159  void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
160  void VisitNoInitExpr(NoInitExpr *E) { } // Do nothing.
161  void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
162  Visit(DAE->getExpr());
163  }
164  void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
166  Visit(DIE->getExpr());
167  }
168  void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
169  void VisitCXXConstructExpr(const CXXConstructExpr *E);
170  void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
171  void VisitLambdaExpr(LambdaExpr *E);
172  void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
173  void VisitExprWithCleanups(ExprWithCleanups *E);
174  void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
175  void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); }
176  void VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
177  void VisitOpaqueValueExpr(OpaqueValueExpr *E);
178 
179  void VisitPseudoObjectExpr(PseudoObjectExpr *E) {
180  if (E->isGLValue()) {
181  LValue LV = CGF.EmitPseudoObjectLValue(E);
182  return EmitFinalDestCopy(E->getType(), LV);
183  }
184 
185  CGF.EmitPseudoObjectRValue(E, EnsureSlot(E->getType()));
186  }
187 
188  void VisitVAArgExpr(VAArgExpr *E);
189 
190  void EmitInitializationToLValue(Expr *E, LValue Address);
191  void EmitNullInitializationToLValue(LValue Address);
192  // case Expr::ChooseExprClass:
193  void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
194  void VisitAtomicExpr(AtomicExpr *E) {
195  RValue Res = CGF.EmitAtomicExpr(E);
196  EmitFinalDestCopy(E->getType(), Res);
197  }
198 };
199 } // end anonymous namespace.
200 
201 //===----------------------------------------------------------------------===//
202 // Utilities
203 //===----------------------------------------------------------------------===//
204 
205 /// EmitAggLoadOfLValue - Given an expression with aggregate type that
206 /// represents a value lvalue, this method emits the address of the lvalue,
207 /// then loads the result into DestPtr.
208 void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
209  LValue LV = CGF.EmitLValue(E);
210 
211  // If the type of the l-value is atomic, then do an atomic load.
212  if (LV.getType()->isAtomicType() || CGF.LValueIsSuitableForInlineAtomic(LV)) {
213  CGF.EmitAtomicLoad(LV, E->getExprLoc(), Dest);
214  return;
215  }
216 
217  EmitFinalDestCopy(E->getType(), LV);
218 }
219 
220 /// \brief True if the given aggregate type requires special GC API calls.
221 bool AggExprEmitter::TypeRequiresGCollection(QualType T) {
222  // Only record types have members that might require garbage collection.
223  const RecordType *RecordTy = T->getAs<RecordType>();
224  if (!RecordTy) return false;
225 
226  // Don't mess with non-trivial C++ types.
227  RecordDecl *Record = RecordTy->getDecl();
228  if (isa<CXXRecordDecl>(Record) &&
229  (cast<CXXRecordDecl>(Record)->hasNonTrivialCopyConstructor() ||
230  !cast<CXXRecordDecl>(Record)->hasTrivialDestructor()))
231  return false;
232 
233  // Check whether the type has an object member.
234  return Record->hasObjectMember();
235 }
236 
237 /// \brief Perform the final move to DestPtr if for some reason
238 /// getReturnValueSlot() didn't use it directly.
239 ///
240 /// The idea is that you do something like this:
241 /// RValue Result = EmitSomething(..., getReturnValueSlot());
242 /// EmitMoveFromReturnSlot(E, Result);
243 ///
244 /// If nothing interferes, this will cause the result to be emitted
245 /// directly into the return value slot. Otherwise, a final move
246 /// will be performed.
247 void AggExprEmitter::EmitMoveFromReturnSlot(const Expr *E, RValue src) {
248  if (shouldUseDestForReturnSlot()) {
249  // Logically, Dest.getAddr() should equal Src.getAggregateAddr().
250  // The possibility of undef rvalues complicates that a lot,
251  // though, so we can't really assert.
252  return;
253  }
254 
255  // Otherwise, copy from there to the destination.
256  assert(Dest.getPointer() != src.getAggregatePointer());
257  EmitFinalDestCopy(E->getType(), src);
258 }
259 
260 /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
261 void AggExprEmitter::EmitFinalDestCopy(QualType type, RValue src) {
262  assert(src.isAggregate() && "value must be aggregate value!");
263  LValue srcLV = CGF.MakeAddrLValue(src.getAggregateAddress(), type);
264  EmitFinalDestCopy(type, srcLV);
265 }
266 
267 /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
268 void AggExprEmitter::EmitFinalDestCopy(QualType type, const LValue &src) {
269  // If Dest is ignored, then we're evaluating an aggregate expression
270  // in a context that doesn't care about the result. Note that loads
271  // from volatile l-values force the existence of a non-ignored
272  // destination.
273  if (Dest.isIgnored())
274  return;
275 
276  AggValueSlot srcAgg =
278  needsGC(type), AggValueSlot::IsAliased);
279  EmitCopy(type, Dest, srcAgg);
280 }
281 
282 /// Perform a copy from the source into the destination.
283 ///
284 /// \param type - the type of the aggregate being copied; qualifiers are
285 /// ignored
286 void AggExprEmitter::EmitCopy(QualType type, const AggValueSlot &dest,
287  const AggValueSlot &src) {
288  if (dest.requiresGCollection()) {
289  CharUnits sz = CGF.getContext().getTypeSizeInChars(type);
290  llvm::Value *size = llvm::ConstantInt::get(CGF.SizeTy, sz.getQuantity());
292  dest.getAddress(),
293  src.getAddress(),
294  size);
295  return;
296  }
297 
298  // If the result of the assignment is used, copy the LHS there also.
299  // It's volatile if either side is. Use the minimum alignment of
300  // the two sides.
301  CGF.EmitAggregateCopy(dest.getAddress(), src.getAddress(), type,
302  dest.isVolatile() || src.isVolatile());
303 }
304 
305 /// \brief Emit the initializer for a std::initializer_list initialized with a
306 /// real initializer list.
307 void
308 AggExprEmitter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
309  // Emit an array containing the elements. The array is externally destructed
310  // if the std::initializer_list object is.
311  ASTContext &Ctx = CGF.getContext();
312  LValue Array = CGF.EmitLValue(E->getSubExpr());
313  assert(Array.isSimple() && "initializer_list array not a simple lvalue");
314  Address ArrayPtr = Array.getAddress();
315 
318  assert(ArrayType && "std::initializer_list constructed from non-array");
319 
320  // FIXME: Perform the checks on the field types in SemaInit.
321  RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
323  if (Field == Record->field_end()) {
324  CGF.ErrorUnsupported(E, "weird std::initializer_list");
325  return;
326  }
327 
328  // Start pointer.
329  if (!Field->getType()->isPointerType() ||
330  !Ctx.hasSameType(Field->getType()->getPointeeType(),
331  ArrayType->getElementType())) {
332  CGF.ErrorUnsupported(E, "weird std::initializer_list");
333  return;
334  }
335 
336  AggValueSlot Dest = EnsureSlot(E->getType());
337  LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
338  LValue Start = CGF.EmitLValueForFieldInitialization(DestLV, *Field);
339  llvm::Value *Zero = llvm::ConstantInt::get(CGF.PtrDiffTy, 0);
340  llvm::Value *IdxStart[] = { Zero, Zero };
341  llvm::Value *ArrayStart =
342  Builder.CreateInBoundsGEP(ArrayPtr.getPointer(), IdxStart, "arraystart");
343  CGF.EmitStoreThroughLValue(RValue::get(ArrayStart), Start);
344  ++Field;
345 
346  if (Field == Record->field_end()) {
347  CGF.ErrorUnsupported(E, "weird std::initializer_list");
348  return;
349  }
350 
351  llvm::Value *Size = Builder.getInt(ArrayType->getSize());
352  LValue EndOrLength = CGF.EmitLValueForFieldInitialization(DestLV, *Field);
353  if (Field->getType()->isPointerType() &&
354  Ctx.hasSameType(Field->getType()->getPointeeType(),
355  ArrayType->getElementType())) {
356  // End pointer.
357  llvm::Value *IdxEnd[] = { Zero, Size };
358  llvm::Value *ArrayEnd =
359  Builder.CreateInBoundsGEP(ArrayPtr.getPointer(), IdxEnd, "arrayend");
360  CGF.EmitStoreThroughLValue(RValue::get(ArrayEnd), EndOrLength);
361  } else if (Ctx.hasSameType(Field->getType(), Ctx.getSizeType())) {
362  // Length.
363  CGF.EmitStoreThroughLValue(RValue::get(Size), EndOrLength);
364  } else {
365  CGF.ErrorUnsupported(E, "weird std::initializer_list");
366  return;
367  }
368 }
369 
370 /// \brief Determine if E is a trivial array filler, that is, one that is
371 /// equivalent to zero-initialization.
372 static bool isTrivialFiller(Expr *E) {
373  if (!E)
374  return true;
375 
376  if (isa<ImplicitValueInitExpr>(E))
377  return true;
378 
379  if (auto *ILE = dyn_cast<InitListExpr>(E)) {
380  if (ILE->getNumInits())
381  return false;
382  return isTrivialFiller(ILE->getArrayFiller());
383  }
384 
385  if (auto *Cons = dyn_cast_or_null<CXXConstructExpr>(E))
386  return Cons->getConstructor()->isDefaultConstructor() &&
387  Cons->getConstructor()->isTrivial();
388 
389  // FIXME: Are there other cases where we can avoid emitting an initializer?
390  return false;
391 }
392 
393 /// \brief Emit initialization of an array from an initializer list.
394 void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,
395  QualType elementType, InitListExpr *E) {
396  uint64_t NumInitElements = E->getNumInits();
397 
398  uint64_t NumArrayElements = AType->getNumElements();
399  assert(NumInitElements <= NumArrayElements);
400 
401  // DestPtr is an array*. Construct an elementType* by drilling
402  // down a level.
403  llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
404  llvm::Value *indices[] = { zero, zero };
405  llvm::Value *begin =
406  Builder.CreateInBoundsGEP(DestPtr.getPointer(), indices, "arrayinit.begin");
407 
408  CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
409  CharUnits elementAlign =
410  DestPtr.getAlignment().alignmentOfArrayElement(elementSize);
411 
412  // Exception safety requires us to destroy all the
413  // already-constructed members if an initializer throws.
414  // For that, we'll need an EH cleanup.
415  QualType::DestructionKind dtorKind = elementType.isDestructedType();
416  Address endOfInit = Address::invalid();
418  llvm::Instruction *cleanupDominator = nullptr;
419  if (CGF.needsEHCleanup(dtorKind)) {
420  // In principle we could tell the cleanup where we are more
421  // directly, but the control flow can get so varied here that it
422  // would actually be quite complex. Therefore we go through an
423  // alloca.
424  endOfInit = CGF.CreateTempAlloca(begin->getType(), CGF.getPointerAlign(),
425  "arrayinit.endOfInit");
426  cleanupDominator = Builder.CreateStore(begin, endOfInit);
427  CGF.pushIrregularPartialArrayCleanup(begin, endOfInit, elementType,
428  elementAlign,
429  CGF.getDestroyer(dtorKind));
430  cleanup = CGF.EHStack.stable_begin();
431 
432  // Otherwise, remember that we didn't need a cleanup.
433  } else {
434  dtorKind = QualType::DK_none;
435  }
436 
437  llvm::Value *one = llvm::ConstantInt::get(CGF.SizeTy, 1);
438 
439  // The 'current element to initialize'. The invariants on this
440  // variable are complicated. Essentially, after each iteration of
441  // the loop, it points to the last initialized element, except
442  // that it points to the beginning of the array before any
443  // elements have been initialized.
444  llvm::Value *element = begin;
445 
446  // Emit the explicit initializers.
447  for (uint64_t i = 0; i != NumInitElements; ++i) {
448  // Advance to the next element.
449  if (i > 0) {
450  element = Builder.CreateInBoundsGEP(element, one, "arrayinit.element");
451 
452  // Tell the cleanup that it needs to destroy up to this
453  // element. TODO: some of these stores can be trivially
454  // observed to be unnecessary.
455  if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit);
456  }
457 
458  LValue elementLV =
459  CGF.MakeAddrLValue(Address(element, elementAlign), elementType);
460  EmitInitializationToLValue(E->getInit(i), elementLV);
461  }
462 
463  // Check whether there's a non-trivial array-fill expression.
464  Expr *filler = E->getArrayFiller();
465  bool hasTrivialFiller = isTrivialFiller(filler);
466 
467  // Any remaining elements need to be zero-initialized, possibly
468  // using the filler expression. We can skip this if the we're
469  // emitting to zeroed memory.
470  if (NumInitElements != NumArrayElements &&
471  !(Dest.isZeroed() && hasTrivialFiller &&
472  CGF.getTypes().isZeroInitializable(elementType))) {
473 
474  // Use an actual loop. This is basically
475  // do { *array++ = filler; } while (array != end);
476 
477  // Advance to the start of the rest of the array.
478  if (NumInitElements) {
479  element = Builder.CreateInBoundsGEP(element, one, "arrayinit.start");
480  if (endOfInit.isValid()) Builder.CreateStore(element, endOfInit);
481  }
482 
483  // Compute the end of the array.
484  llvm::Value *end = Builder.CreateInBoundsGEP(begin,
485  llvm::ConstantInt::get(CGF.SizeTy, NumArrayElements),
486  "arrayinit.end");
487 
488  llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
489  llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body");
490 
491  // Jump into the body.
492  CGF.EmitBlock(bodyBB);
493  llvm::PHINode *currentElement =
494  Builder.CreatePHI(element->getType(), 2, "arrayinit.cur");
495  currentElement->addIncoming(element, entryBB);
496 
497  // Emit the actual filler expression.
498  {
499  // C++1z [class.temporary]p5:
500  // when a default constructor is called to initialize an element of
501  // an array with no corresponding initializer [...] the destruction of
502  // every temporary created in a default argument is sequenced before
503  // the construction of the next array element, if any
504  CodeGenFunction::RunCleanupsScope CleanupsScope(CGF);
505  LValue elementLV =
506  CGF.MakeAddrLValue(Address(currentElement, elementAlign), elementType);
507  if (filler)
508  EmitInitializationToLValue(filler, elementLV);
509  else
510  EmitNullInitializationToLValue(elementLV);
511  }
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()) {
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.
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())
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:
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_ZeroToOCLQueue:
753  case CK_AddressSpaceConversion:
754  case CK_IntToOCLSampler:
755  llvm_unreachable("cast kind invalid for aggregate types");
756  }
757 }
758 
759 void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
760  if (E->getCallReturnType(CGF.getContext())->isReferenceType()) {
761  EmitAggLoadOfLValue(E);
762  return;
763  }
764 
765  RValue RV = CGF.EmitCallExpr(E, getReturnValueSlot());
766  EmitMoveFromReturnSlot(E, RV);
767 }
768 
769 void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
770  RValue RV = CGF.EmitObjCMessageExpr(E, getReturnValueSlot());
771  EmitMoveFromReturnSlot(E, RV);
772 }
773 
774 void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
775  CGF.EmitIgnoredExpr(E->getLHS());
776  Visit(E->getRHS());
777 }
778 
779 void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
781  CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest);
782 }
783 
784 void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
785  if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI)
786  VisitPointerToDataMemberBinaryOperator(E);
787  else
788  CGF.ErrorUnsupported(E, "aggregate binary expression");
789 }
790 
791 void AggExprEmitter::VisitPointerToDataMemberBinaryOperator(
792  const BinaryOperator *E) {
794  EmitFinalDestCopy(E->getType(), LV);
795 }
796 
797 /// Is the value of the given expression possibly a reference to or
798 /// into a __block variable?
799 static bool isBlockVarRef(const Expr *E) {
800  // Make sure we look through parens.
801  E = E->IgnoreParens();
802 
803  // Check for a direct reference to a __block variable.
804  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
805  const VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl());
806  return (var && var->hasAttr<BlocksAttr>());
807  }
808 
809  // More complicated stuff.
810 
811  // Binary operators.
812  if (const BinaryOperator *op = dyn_cast<BinaryOperator>(E)) {
813  // For an assignment or pointer-to-member operation, just care
814  // about the LHS.
815  if (op->isAssignmentOp() || op->isPtrMemOp())
816  return isBlockVarRef(op->getLHS());
817 
818  // For a comma, just care about the RHS.
819  if (op->getOpcode() == BO_Comma)
820  return isBlockVarRef(op->getRHS());
821 
822  // FIXME: pointer arithmetic?
823  return false;
824 
825  // Check both sides of a conditional operator.
826  } else if (const AbstractConditionalOperator *op
827  = dyn_cast<AbstractConditionalOperator>(E)) {
828  return isBlockVarRef(op->getTrueExpr())
829  || isBlockVarRef(op->getFalseExpr());
830 
831  // OVEs are required to support BinaryConditionalOperators.
832  } else if (const OpaqueValueExpr *op
833  = dyn_cast<OpaqueValueExpr>(E)) {
834  if (const Expr *src = op->getSourceExpr())
835  return isBlockVarRef(src);
836 
837  // Casts are necessary to get things like (*(int*)&var) = foo().
838  // We don't really care about the kind of cast here, except
839  // we don't want to look through l2r casts, because it's okay
840  // to get the *value* in a __block variable.
841  } else if (const CastExpr *cast = dyn_cast<CastExpr>(E)) {
842  if (cast->getCastKind() == CK_LValueToRValue)
843  return false;
844  return isBlockVarRef(cast->getSubExpr());
845 
846  // Handle unary operators. Again, just aggressively look through
847  // it, ignoring the operation.
848  } else if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E)) {
849  return isBlockVarRef(uop->getSubExpr());
850 
851  // Look into the base of a field access.
852  } else if (const MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
853  return isBlockVarRef(mem->getBase());
854 
855  // Look into the base of a subscript.
856  } else if (const ArraySubscriptExpr *sub = dyn_cast<ArraySubscriptExpr>(E)) {
857  return isBlockVarRef(sub->getBase());
858  }
859 
860  return false;
861 }
862 
863 void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
864  // For an assignment to work, the value on the right has
865  // to be compatible with the value on the left.
866  assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
867  E->getRHS()->getType())
868  && "Invalid assignment");
869 
870  // If the LHS might be a __block variable, and the RHS can
871  // potentially cause a block copy, we need to evaluate the RHS first
872  // so that the assignment goes the right place.
873  // This is pretty semantically fragile.
874  if (isBlockVarRef(E->getLHS()) &&
875  E->getRHS()->HasSideEffects(CGF.getContext())) {
876  // Ensure that we have a destination, and evaluate the RHS into that.
877  EnsureDest(E->getRHS()->getType());
878  Visit(E->getRHS());
879 
880  // Now emit the LHS and copy into it.
882 
883  // That copy is an atomic copy if the LHS is atomic.
884  if (LHS.getType()->isAtomicType() ||
886  CGF.EmitAtomicStore(Dest.asRValue(), LHS, /*isInit*/ false);
887  return;
888  }
889 
890  EmitCopy(E->getLHS()->getType(),
892  needsGC(E->getLHS()->getType()),
894  Dest);
895  return;
896  }
897 
898  LValue LHS = CGF.EmitLValue(E->getLHS());
899 
900  // If we have an atomic type, evaluate into the destination and then
901  // do an atomic copy.
902  if (LHS.getType()->isAtomicType() ||
904  EnsureDest(E->getRHS()->getType());
905  Visit(E->getRHS());
906  CGF.EmitAtomicStore(Dest.asRValue(), LHS, /*isInit*/ false);
907  return;
908  }
909 
910  // Codegen the RHS so that it stores directly into the LHS.
911  AggValueSlot LHSSlot =
913  needsGC(E->getLHS()->getType()),
915  // A non-volatile aggregate destination might have volatile member.
916  if (!LHSSlot.isVolatile() &&
917  CGF.hasVolatileMember(E->getLHS()->getType()))
918  LHSSlot.setVolatile(true);
919 
920  CGF.EmitAggExpr(E->getRHS(), LHSSlot);
921 
922  // Copy into the destination if the assignment isn't ignored.
923  EmitFinalDestCopy(E->getType(), LHS);
924 }
925 
926 void AggExprEmitter::
927 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
928  llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
929  llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
930  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
931 
932  // Bind the common expression if necessary.
933  CodeGenFunction::OpaqueValueMapping binding(CGF, E);
934 
936  CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock,
937  CGF.getProfileCount(E));
938 
939  // Save whether the destination's lifetime is externally managed.
940  bool isExternallyDestructed = Dest.isExternallyDestructed();
941 
942  eval.begin(CGF);
943  CGF.EmitBlock(LHSBlock);
945  Visit(E->getTrueExpr());
946  eval.end(CGF);
947 
948  assert(CGF.HaveInsertPoint() && "expression evaluation ended with no IP!");
949  CGF.Builder.CreateBr(ContBlock);
950 
951  // If the result of an agg expression is unused, then the emission
952  // of the LHS might need to create a destination slot. That's fine
953  // with us, and we can safely emit the RHS into the same slot, but
954  // we shouldn't claim that it's already being destructed.
955  Dest.setExternallyDestructed(isExternallyDestructed);
956 
957  eval.begin(CGF);
958  CGF.EmitBlock(RHSBlock);
959  Visit(E->getFalseExpr());
960  eval.end(CGF);
961 
962  CGF.EmitBlock(ContBlock);
963 }
964 
965 void AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) {
966  Visit(CE->getChosenSubExpr());
967 }
968 
969 void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
970  Address ArgValue = Address::invalid();
971  Address ArgPtr = CGF.EmitVAArg(VE, ArgValue);
972 
973  // If EmitVAArg fails, emit an error.
974  if (!ArgPtr.isValid()) {
975  CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
976  return;
977  }
978 
979  EmitFinalDestCopy(VE->getType(), CGF.MakeAddrLValue(ArgPtr, VE->getType()));
980 }
981 
982 void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
983  // Ensure that we have a slot, but if we already do, remember
984  // whether it was externally destructed.
985  bool wasExternallyDestructed = Dest.isExternallyDestructed();
986  EnsureDest(E->getType());
987 
988  // We're going to push a destructor if there isn't already one.
990 
991  Visit(E->getSubExpr());
992 
993  // Push that destructor we promised.
994  if (!wasExternallyDestructed)
995  CGF.EmitCXXTemporary(E->getTemporary(), E->getType(), Dest.getAddress());
996 }
997 
998 void
999 AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {
1000  AggValueSlot Slot = EnsureSlot(E->getType());
1001  CGF.EmitCXXConstructExpr(E, Slot);
1002 }
1003 
1004 void AggExprEmitter::VisitCXXInheritedCtorInitExpr(
1005  const CXXInheritedCtorInitExpr *E) {
1006  AggValueSlot Slot = EnsureSlot(E->getType());
1008  E->getConstructor(), E->constructsVBase(), Slot.getAddress(),
1009  E->inheritedFromVBase(), E);
1010 }
1011 
1012 void
1013 AggExprEmitter::VisitLambdaExpr(LambdaExpr *E) {
1014  AggValueSlot Slot = EnsureSlot(E->getType());
1015  CGF.EmitLambdaExpr(E, Slot);
1016 }
1017 
1018 void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
1019  CGF.enterFullExpression(E);
1020  CodeGenFunction::RunCleanupsScope cleanups(CGF);
1021  Visit(E->getSubExpr());
1022 }
1023 
1024 void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1025  QualType T = E->getType();
1026  AggValueSlot Slot = EnsureSlot(T);
1027  EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T));
1028 }
1029 
1030 void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1031  QualType T = E->getType();
1032  AggValueSlot Slot = EnsureSlot(T);
1033  EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddress(), T));
1034 }
1035 
1036 /// isSimpleZero - If emitting this value will obviously just cause a store of
1037 /// zero to memory, return true. This can return false if uncertain, so it just
1038 /// handles simple cases.
1039 static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {
1040  E = E->IgnoreParens();
1041 
1042  // 0
1043  if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
1044  return IL->getValue() == 0;
1045  // +0.0
1046  if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E))
1047  return FL->getValue().isPosZero();
1048  // int()
1049  if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) &&
1050  CGF.getTypes().isZeroInitializable(E->getType()))
1051  return true;
1052  // (int*)0 - Null pointer expressions.
1053  if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
1054  return ICE->getCastKind() == CK_NullToPointer &&
1056  // '\0'
1057  if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E))
1058  return CL->getValue() == 0;
1059 
1060  // Otherwise, hard case: conservatively return false.
1061  return false;
1062 }
1063 
1064 
1065 void
1066 AggExprEmitter::EmitInitializationToLValue(Expr *E, LValue LV) {
1067  QualType type = LV.getType();
1068  // FIXME: Ignore result?
1069  // FIXME: Are initializers affected by volatile?
1070  if (Dest.isZeroed() && isSimpleZero(E, CGF)) {
1071  // Storing "i32 0" to a zero'd memory location is a noop.
1072  return;
1073  } else if (isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) {
1074  return EmitNullInitializationToLValue(LV);
1075  } else if (isa<NoInitExpr>(E)) {
1076  // Do nothing.
1077  return;
1078  } else if (type->isReferenceType()) {
1079  RValue RV = CGF.EmitReferenceBindingToExpr(E);
1080  return CGF.EmitStoreThroughLValue(RV, LV);
1081  }
1082 
1083  switch (CGF.getEvaluationKind(type)) {
1084  case TEK_Complex:
1085  CGF.EmitComplexExprIntoLValue(E, LV, /*isInit*/ true);
1086  return;
1087  case TEK_Aggregate:
1092  Dest.isZeroed()));
1093  return;
1094  case TEK_Scalar:
1095  if (LV.isSimple()) {
1096  CGF.EmitScalarInit(E, /*D=*/nullptr, LV, /*Captured=*/false);
1097  } else {
1099  }
1100  return;
1101  }
1102  llvm_unreachable("bad evaluation kind");
1103 }
1104 
1105 void AggExprEmitter::EmitNullInitializationToLValue(LValue lv) {
1106  QualType type = lv.getType();
1107 
1108  // If the destination slot is already zeroed out before the aggregate is
1109  // copied into it, we don't have to emit any zeros here.
1110  if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(type))
1111  return;
1112 
1113  if (CGF.hasScalarEvaluationKind(type)) {
1114  // For non-aggregates, we can store the appropriate null constant.
1115  llvm::Value *null = CGF.CGM.EmitNullConstant(type);
1116  // Note that the following is not equivalent to
1117  // EmitStoreThroughBitfieldLValue for ARC types.
1118  if (lv.isBitField()) {
1120  } else {
1121  assert(lv.isSimple());
1122  CGF.EmitStoreOfScalar(null, lv, /* isInitialization */ true);
1123  }
1124  } else {
1125  // There's a potential optimization opportunity in combining
1126  // memsets; that would be easy for arrays, but relatively
1127  // difficult for structures with the current code.
1128  CGF.EmitNullInitialization(lv.getAddress(), lv.getType());
1129  }
1130 }
1131 
1132 void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
1133 #if 0
1134  // FIXME: Assess perf here? Figure out what cases are worth optimizing here
1135  // (Length of globals? Chunks of zeroed-out space?).
1136  //
1137  // If we can, prefer a copy from a global; this is a lot less code for long
1138  // globals, and it's easier for the current optimizers to analyze.
1139  if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) {
1140  llvm::GlobalVariable* GV =
1141  new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true,
1143  EmitFinalDestCopy(E->getType(), CGF.MakeAddrLValue(GV, E->getType()));
1144  return;
1145  }
1146 #endif
1147  if (E->hadArrayRangeDesignator())
1148  CGF.ErrorUnsupported(E, "GNU array range designator extension");
1149 
1150  if (E->isTransparent())
1151  return Visit(E->getInit(0));
1152 
1153  AggValueSlot Dest = EnsureSlot(E->getType());
1154 
1155  LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1156 
1157  // Handle initialization of an array.
1158  if (E->getType()->isArrayType()) {
1159  QualType elementType =
1160  CGF.getContext().getAsArrayType(E->getType())->getElementType();
1161 
1162  auto AType = cast<llvm::ArrayType>(Dest.getAddress().getElementType());
1163  EmitArrayInit(Dest.getAddress(), AType, elementType, E);
1164  return;
1165  }
1166 
1167  assert(E->getType()->isRecordType() && "Only support structs/unions here!");
1168 
1169  // Do struct initialization; this code just sets each individual member
1170  // to the approprate value. This makes bitfield support automatic;
1171  // the disadvantage is that the generated code is more difficult for
1172  // the optimizer, especially with bitfields.
1173  unsigned NumInitElements = E->getNumInits();
1174  RecordDecl *record = E->getType()->castAs<RecordType>()->getDecl();
1175 
1176  // We'll need to enter cleanup scopes in case any of the element
1177  // initializers throws an exception.
1179  llvm::Instruction *cleanupDominator = nullptr;
1180 
1181  unsigned curInitIndex = 0;
1182 
1183  // Emit initialization of base classes.
1184  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(record)) {
1185  assert(E->getNumInits() >= CXXRD->getNumBases() &&
1186  "missing initializer for base class");
1187  for (auto &Base : CXXRD->bases()) {
1188  assert(!Base.isVirtual() && "should not see vbases here");
1189  auto *BaseRD = Base.getType()->getAsCXXRecordDecl();
1191  Dest.getAddress(), CXXRD, BaseRD,
1192  /*isBaseVirtual*/ false);
1193  AggValueSlot AggSlot =
1198  CGF.EmitAggExpr(E->getInit(curInitIndex++), AggSlot);
1199 
1200  if (QualType::DestructionKind dtorKind =
1201  Base.getType().isDestructedType()) {
1202  CGF.pushDestroy(dtorKind, V, Base.getType());
1203  cleanups.push_back(CGF.EHStack.stable_begin());
1204  }
1205  }
1206  }
1207 
1208  // Prepare a 'this' for CXXDefaultInitExprs.
1210 
1211  if (record->isUnion()) {
1212  // Only initialize one field of a union. The field itself is
1213  // specified by the initializer list.
1214  if (!E->getInitializedFieldInUnion()) {
1215  // Empty union; we have nothing to do.
1216 
1217 #ifndef NDEBUG
1218  // Make sure that it's really an empty and not a failure of
1219  // semantic analysis.
1220  for (const auto *Field : record->fields())
1221  assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
1222 #endif
1223  return;
1224  }
1225 
1226  // FIXME: volatility
1227  FieldDecl *Field = E->getInitializedFieldInUnion();
1228 
1229  LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestLV, Field);
1230  if (NumInitElements) {
1231  // Store the initializer into the field
1232  EmitInitializationToLValue(E->getInit(0), FieldLoc);
1233  } else {
1234  // Default-initialize to null.
1235  EmitNullInitializationToLValue(FieldLoc);
1236  }
1237 
1238  return;
1239  }
1240 
1241  // Here we iterate over the fields; this makes it simpler to both
1242  // default-initialize fields and skip over unnamed fields.
1243  for (const auto *field : record->fields()) {
1244  // We're done once we hit the flexible array member.
1245  if (field->getType()->isIncompleteArrayType())
1246  break;
1247 
1248  // Always skip anonymous bitfields.
1249  if (field->isUnnamedBitfield())
1250  continue;
1251 
1252  // We're done if we reach the end of the explicit initializers, we
1253  // have a zeroed object, and the rest of the fields are
1254  // zero-initializable.
1255  if (curInitIndex == NumInitElements && Dest.isZeroed() &&
1256  CGF.getTypes().isZeroInitializable(E->getType()))
1257  break;
1258 
1259 
1260  LValue LV = CGF.EmitLValueForFieldInitialization(DestLV, field);
1261  // We never generate write-barries for initialized fields.
1262  LV.setNonGC(true);
1263 
1264  if (curInitIndex < NumInitElements) {
1265  // Store the initializer into the field.
1266  EmitInitializationToLValue(E->getInit(curInitIndex++), LV);
1267  } else {
1268  // We're out of initializers; default-initialize to null
1269  EmitNullInitializationToLValue(LV);
1270  }
1271 
1272  // Push a destructor if necessary.
1273  // FIXME: if we have an array of structures, all explicitly
1274  // initialized, we can end up pushing a linear number of cleanups.
1275  bool pushedCleanup = false;
1276  if (QualType::DestructionKind dtorKind
1277  = field->getType().isDestructedType()) {
1278  assert(LV.isSimple());
1279  if (CGF.needsEHCleanup(dtorKind)) {
1280  if (!cleanupDominator)
1281  cleanupDominator = CGF.Builder.CreateAlignedLoad(
1282  CGF.Int8Ty,
1283  llvm::Constant::getNullValue(CGF.Int8PtrTy),
1284  CharUnits::One()); // placeholder
1285 
1286  CGF.pushDestroy(EHCleanup, LV.getAddress(), field->getType(),
1287  CGF.getDestroyer(dtorKind), false);
1288  cleanups.push_back(CGF.EHStack.stable_begin());
1289  pushedCleanup = true;
1290  }
1291  }
1292 
1293  // If the GEP didn't get used because of a dead zero init or something
1294  // else, clean it up for -O0 builds and general tidiness.
1295  if (!pushedCleanup && LV.isSimple())
1296  if (llvm::GetElementPtrInst *GEP =
1297  dyn_cast<llvm::GetElementPtrInst>(LV.getPointer()))
1298  if (GEP->use_empty())
1299  GEP->eraseFromParent();
1300  }
1301 
1302  // Deactivate all the partial cleanups in reverse order, which
1303  // generally means popping them.
1304  for (unsigned i = cleanups.size(); i != 0; --i)
1305  CGF.DeactivateCleanupBlock(cleanups[i-1], cleanupDominator);
1306 
1307  // Destroy the placeholder if we made one.
1308  if (cleanupDominator)
1309  cleanupDominator->eraseFromParent();
1310 }
1311 
1312 void AggExprEmitter::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E,
1313  llvm::Value *outerBegin) {
1314  // Emit the common subexpression.
1316 
1317  Address destPtr = EnsureSlot(E->getType()).getAddress();
1318  uint64_t numElements = E->getArraySize().getZExtValue();
1319 
1320  if (!numElements)
1321  return;
1322 
1323  // destPtr is an array*. Construct an elementType* by drilling down a level.
1324  llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
1325  llvm::Value *indices[] = {zero, zero};
1326  llvm::Value *begin = Builder.CreateInBoundsGEP(destPtr.getPointer(), indices,
1327  "arrayinit.begin");
1328 
1329  // Prepare to special-case multidimensional array initialization: we avoid
1330  // emitting multiple destructor loops in that case.
1331  if (!outerBegin)
1332  outerBegin = begin;
1333  ArrayInitLoopExpr *InnerLoop = dyn_cast<ArrayInitLoopExpr>(E->getSubExpr());
1334 
1335  QualType elementType =
1336  CGF.getContext().getAsArrayType(E->getType())->getElementType();
1337  CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
1338  CharUnits elementAlign =
1339  destPtr.getAlignment().alignmentOfArrayElement(elementSize);
1340 
1341  llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
1342  llvm::BasicBlock *bodyBB = CGF.createBasicBlock("arrayinit.body");
1343 
1344  // Jump into the body.
1345  CGF.EmitBlock(bodyBB);
1346  llvm::PHINode *index =
1347  Builder.CreatePHI(zero->getType(), 2, "arrayinit.index");
1348  index->addIncoming(zero, entryBB);
1349  llvm::Value *element = Builder.CreateInBoundsGEP(begin, index);
1350 
1351  // Prepare for a cleanup.
1352  QualType::DestructionKind dtorKind = elementType.isDestructedType();
1354  if (CGF.needsEHCleanup(dtorKind) && !InnerLoop) {
1355  if (outerBegin->getType() != element->getType())
1356  outerBegin = Builder.CreateBitCast(outerBegin, element->getType());
1357  CGF.pushRegularPartialArrayCleanup(outerBegin, element, elementType,
1358  elementAlign,
1359  CGF.getDestroyer(dtorKind));
1360  cleanup = CGF.EHStack.stable_begin();
1361  } else {
1362  dtorKind = QualType::DK_none;
1363  }
1364 
1365  // Emit the actual filler expression.
1366  {
1367  // Temporaries created in an array initialization loop are destroyed
1368  // at the end of each iteration.
1369  CodeGenFunction::RunCleanupsScope CleanupsScope(CGF);
1371  LValue elementLV =
1372  CGF.MakeAddrLValue(Address(element, elementAlign), elementType);
1373 
1374  if (InnerLoop) {
1375  // If the subexpression is an ArrayInitLoopExpr, share its cleanup.
1376  auto elementSlot = AggValueSlot::forLValue(
1377  elementLV, AggValueSlot::IsDestructed,
1379  AggExprEmitter(CGF, elementSlot, false)
1380  .VisitArrayInitLoopExpr(InnerLoop, outerBegin);
1381  } else
1382  EmitInitializationToLValue(E->getSubExpr(), elementLV);
1383  }
1384 
1385  // Move on to the next element.
1386  llvm::Value *nextIndex = Builder.CreateNUWAdd(
1387  index, llvm::ConstantInt::get(CGF.SizeTy, 1), "arrayinit.next");
1388  index->addIncoming(nextIndex, Builder.GetInsertBlock());
1389 
1390  // Leave the loop if we're done.
1391  llvm::Value *done = Builder.CreateICmpEQ(
1392  nextIndex, llvm::ConstantInt::get(CGF.SizeTy, numElements),
1393  "arrayinit.done");
1394  llvm::BasicBlock *endBB = CGF.createBasicBlock("arrayinit.end");
1395  Builder.CreateCondBr(done, endBB, bodyBB);
1396 
1397  CGF.EmitBlock(endBB);
1398 
1399  // Leave the partial-array cleanup if we entered one.
1400  if (dtorKind)
1401  CGF.DeactivateCleanupBlock(cleanup, index);
1402 }
1403 
1404 void AggExprEmitter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1405  AggValueSlot Dest = EnsureSlot(E->getType());
1406 
1407  LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1408  EmitInitializationToLValue(E->getBase(), DestLV);
1409  VisitInitListExpr(E->getUpdater());
1410 }
1411 
1412 //===----------------------------------------------------------------------===//
1413 // Entry Points into this File
1414 //===----------------------------------------------------------------------===//
1415 
1416 /// GetNumNonZeroBytesInInit - Get an approximate count of the number of
1417 /// non-zero bytes that will be stored when outputting the initializer for the
1418 /// specified initializer expression.
1420  E = E->IgnoreParens();
1421 
1422  // 0 and 0.0 won't require any non-zero stores!
1423  if (isSimpleZero(E, CGF)) return CharUnits::Zero();
1424 
1425  // If this is an initlist expr, sum up the size of sizes of the (present)
1426  // elements. If this is something weird, assume the whole thing is non-zero.
1427  const InitListExpr *ILE = dyn_cast<InitListExpr>(E);
1428  if (!ILE || !CGF.getTypes().isZeroInitializable(ILE->getType()))
1429  return CGF.getContext().getTypeSizeInChars(E->getType());
1430 
1431  // InitListExprs for structs have to be handled carefully. If there are
1432  // reference members, we need to consider the size of the reference, not the
1433  // referencee. InitListExprs for unions and arrays can't have references.
1434  if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
1435  if (!RT->isUnionType()) {
1436  RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
1437  CharUnits NumNonZeroBytes = CharUnits::Zero();
1438 
1439  unsigned ILEElement = 0;
1440  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(SD))
1441  while (ILEElement != CXXRD->getNumBases())
1442  NumNonZeroBytes +=
1443  GetNumNonZeroBytesInInit(ILE->getInit(ILEElement++), CGF);
1444  for (const auto *Field : SD->fields()) {
1445  // We're done once we hit the flexible array member or run out of
1446  // InitListExpr elements.
1447  if (Field->getType()->isIncompleteArrayType() ||
1448  ILEElement == ILE->getNumInits())
1449  break;
1450  if (Field->isUnnamedBitfield())
1451  continue;
1452 
1453  const Expr *E = ILE->getInit(ILEElement++);
1454 
1455  // Reference values are always non-null and have the width of a pointer.
1456  if (Field->getType()->isReferenceType())
1457  NumNonZeroBytes += CGF.getContext().toCharUnitsFromBits(
1458  CGF.getTarget().getPointerWidth(0));
1459  else
1460  NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF);
1461  }
1462 
1463  return NumNonZeroBytes;
1464  }
1465  }
1466 
1467 
1468  CharUnits NumNonZeroBytes = CharUnits::Zero();
1469  for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
1470  NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF);
1471  return NumNonZeroBytes;
1472 }
1473 
1474 /// CheckAggExprForMemSetUse - If the initializer is large and has a lot of
1475 /// zeros in it, emit a memset and avoid storing the individual zeros.
1476 ///
1477 static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,
1478  CodeGenFunction &CGF) {
1479  // If the slot is already known to be zeroed, nothing to do. Don't mess with
1480  // volatile stores.
1481  if (Slot.isZeroed() || Slot.isVolatile() || !Slot.getAddress().isValid())
1482  return;
1483 
1484  // C++ objects with a user-declared constructor don't need zero'ing.
1485  if (CGF.getLangOpts().CPlusPlus)
1486  if (const RecordType *RT = CGF.getContext()
1487  .getBaseElementType(E->getType())->getAs<RecordType>()) {
1488  const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1489  if (RD->hasUserDeclaredConstructor())
1490  return;
1491  }
1492 
1493  // If the type is 16-bytes or smaller, prefer individual stores over memset.
1494  CharUnits Size = CGF.getContext().getTypeSizeInChars(E->getType());
1495  if (Size <= CharUnits::fromQuantity(16))
1496  return;
1497 
1498  // Check to see if over 3/4 of the initializer are known to be zero. If so,
1499  // we prefer to emit memset + individual stores for the rest.
1500  CharUnits NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF);
1501  if (NumNonZeroBytes*4 > Size)
1502  return;
1503 
1504  // Okay, it seems like a good idea to use an initial memset, emit the call.
1505  llvm::Constant *SizeVal = CGF.Builder.getInt64(Size.getQuantity());
1506 
1507  Address Loc = Slot.getAddress();
1508  Loc = CGF.Builder.CreateElementBitCast(Loc, CGF.Int8Ty);
1509  CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal, false);
1510 
1511  // Tell the AggExprEmitter that the slot is known zero.
1512  Slot.setZeroed();
1513 }
1514 
1515 
1516 
1517 
1518 /// EmitAggExpr - Emit the computation of the specified expression of aggregate
1519 /// type. The result is computed into DestPtr. Note that if DestPtr is null,
1520 /// the value of the aggregate expression is not needed. If VolatileDest is
1521 /// true, DestPtr cannot be 0.
1523  assert(E && hasAggregateEvaluationKind(E->getType()) &&
1524  "Invalid aggregate expression to emit");
1525  assert((Slot.getAddress().isValid() || Slot.isIgnored()) &&
1526  "slot has bits but no address");
1527 
1528  // Optimize the slot if possible.
1529  CheckAggExprForMemSetUse(Slot, E, *this);
1530 
1531  AggExprEmitter(*this, Slot, Slot.isIgnored()).Visit(const_cast<Expr*>(E));
1532 }
1533 
1535  assert(hasAggregateEvaluationKind(E->getType()) && "Invalid argument!");
1536  Address Temp = CreateMemTemp(E->getType());
1537  LValue LV = MakeAddrLValue(Temp, E->getType());
1541  return LV;
1542 }
1543 
1545  Address SrcPtr, QualType Ty,
1546  bool isVolatile,
1547  bool isAssignment) {
1548  assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
1549 
1550  if (getLangOpts().CPlusPlus) {
1551  if (const RecordType *RT = Ty->getAs<RecordType>()) {
1552  CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
1553  assert((Record->hasTrivialCopyConstructor() ||
1554  Record->hasTrivialCopyAssignment() ||
1555  Record->hasTrivialMoveConstructor() ||
1556  Record->hasTrivialMoveAssignment() ||
1557  Record->isUnion()) &&
1558  "Trying to aggregate-copy a type without a trivial copy/move "
1559  "constructor or assignment operator");
1560  // Ignore empty classes in C++.
1561  if (Record->isEmpty())
1562  return;
1563  }
1564  }
1565 
1566  // Aggregate assignment turns into llvm.memcpy. This is almost valid per
1567  // C99 6.5.16.1p3, which states "If the value being stored in an object is
1568  // read from another object that overlaps in anyway the storage of the first
1569  // object, then the overlap shall be exact and the two objects shall have
1570  // qualified or unqualified versions of a compatible type."
1571  //
1572  // memcpy is not defined if the source and destination pointers are exactly
1573  // equal, but other compilers do this optimization, and almost every memcpy
1574  // implementation handles this case safely. If there is a libc that does not
1575  // safely handle this, we can add a target hook.
1576 
1577  // Get data size info for this aggregate. If this is an assignment,
1578  // don't copy the tail padding, because we might be assigning into a
1579  // base subobject where the tail padding is claimed. Otherwise,
1580  // copying it is fine.
1581  std::pair<CharUnits, CharUnits> TypeInfo;
1582  if (isAssignment)
1583  TypeInfo = getContext().getTypeInfoDataSizeInChars(Ty);
1584  else
1585  TypeInfo = getContext().getTypeInfoInChars(Ty);
1586 
1587  llvm::Value *SizeVal = nullptr;
1588  if (TypeInfo.first.isZero()) {
1589  // But note that getTypeInfo returns 0 for a VLA.
1590  if (auto *VAT = dyn_cast_or_null<VariableArrayType>(
1591  getContext().getAsArrayType(Ty))) {
1592  QualType BaseEltTy;
1593  SizeVal = emitArrayLength(VAT, BaseEltTy, DestPtr);
1594  TypeInfo = getContext().getTypeInfoDataSizeInChars(BaseEltTy);
1595  std::pair<CharUnits, CharUnits> LastElementTypeInfo;
1596  if (!isAssignment)
1597  LastElementTypeInfo = getContext().getTypeInfoInChars(BaseEltTy);
1598  assert(!TypeInfo.first.isZero());
1599  SizeVal = Builder.CreateNUWMul(
1600  SizeVal,
1601  llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity()));
1602  if (!isAssignment) {
1603  SizeVal = Builder.CreateNUWSub(
1604  SizeVal,
1605  llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity()));
1606  SizeVal = Builder.CreateNUWAdd(
1607  SizeVal, llvm::ConstantInt::get(
1608  SizeTy, LastElementTypeInfo.first.getQuantity()));
1609  }
1610  }
1611  }
1612  if (!SizeVal) {
1613  SizeVal = llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity());
1614  }
1615 
1616  // FIXME: If we have a volatile struct, the optimizer can remove what might
1617  // appear to be `extra' memory ops:
1618  //
1619  // volatile struct { int i; } a, b;
1620  //
1621  // int main() {
1622  // a = b;
1623  // a = b;
1624  // }
1625  //
1626  // we need to use a different call here. We use isVolatile to indicate when
1627  // either the source or the destination is volatile.
1628 
1629  DestPtr = Builder.CreateElementBitCast(DestPtr, Int8Ty);
1630  SrcPtr = Builder.CreateElementBitCast(SrcPtr, Int8Ty);
1631 
1632  // Don't do any of the memmove_collectable tests if GC isn't set.
1633  if (CGM.getLangOpts().getGC() == LangOptions::NonGC) {
1634  // fall through
1635  } else if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
1636  RecordDecl *Record = RecordTy->getDecl();
1637  if (Record->hasObjectMember()) {
1638  CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
1639  SizeVal);
1640  return;
1641  }
1642  } else if (Ty->isArrayType()) {
1643  QualType BaseType = getContext().getBaseElementType(Ty);
1644  if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
1645  if (RecordTy->getDecl()->hasObjectMember()) {
1646  CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
1647  SizeVal);
1648  return;
1649  }
1650  }
1651  }
1652 
1653  auto Inst = Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, isVolatile);
1654 
1655  // Determine the metadata to describe the position of any padding in this
1656  // memcpy, as well as the TBAA tags for the members of the struct, in case
1657  // the optimizer wishes to expand it in to scalar memory operations.
1658  if (llvm::MDNode *TBAAStructTag = CGM.getTBAAStructInfo(Ty))
1659  Inst->setMetadata(llvm::LLVMContext::MD_tbaa_struct, TBAAStructTag);
1660 }
bool isAggregate() const
Definition: CGValue.h:54
ReturnValueSlot - Contains the address where the return value of a function can be stored...
Definition: CGCall.h:281
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Defines the clang::ASTContext interface.
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Definition: Expr.h:3705
Address getAddress() const
Definition: CGValue.h:555
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
Definition: CGDecl.cpp:1461
A (possibly-)qualified type.
Definition: Type.h:653
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
Definition: Type.cpp:2061
bool isArrayType() const
Definition: Type.h:5993
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)
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
CompoundStmt * getSubStmt()
Definition: Expr.h:3504
static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, IsZeroed_t isZeroed=IsNotZeroed)
Definition: CGValue.h:517
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3920
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
NeedsGCBarriers_t requiresGCollection() const
Definition: CGValue.h:547
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:2029
llvm::Value * getPointer() const
Definition: CGValue.h:551
bool isRecordType() const
Definition: Type.h:6017
Address EmitVAArg(VAArgExpr *VE, Address &VAListAddr)
Generate code to get an argument from the passed in pointer and update it accordingly.
Definition: CGCall.cpp:4393
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:4746
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:1933
Defines the C++ template declaration subclasses.
Opcode getOpcode() const
Definition: Expr.h:3026
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1665
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:1836
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:2560
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1239
bool hasTrivialMoveConstructor() const
Determine whether this class has a trivial move constructor (C++11 [class.copy]p12) ...
Definition: DeclCXX.h:1361
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
Definition: EHScopeStack.h:379
void setZeroed(bool V=true)
Definition: CGValue.h:579
QualType getValueType() const
Gets the type contained by this atomic type, i.e.
Definition: Type.h:5631
LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)
EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference...
Definition: CGExpr.cpp:3847
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:4035
const Expr * getResultExpr() const
The generic selection&#39;s result expression.
Definition: Expr.h:4760
IsAliased_t isPotentiallyAliased() const
Definition: CGValue.h:567
void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit)
Definition: CGAtomic.cpp:1871
QualType getElementType() const
Definition: Type.h:2595
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:799
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:806
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:2637
OpaqueValueExpr * getCommonExpr() const
Get the common subexpression shared by all initializations (the source array).
Definition: Expr.h:4507
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6307
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:1039
IsZeroed_t isZeroed() const
Definition: CGValue.h:580
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition: ExprCXX.h:594
llvm::Value * getPointer() const
Definition: Address.h:38
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will call.
Definition: ExprCXX.h:1435
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:985
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
Definition: ExprCXX.h:3000
void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, llvm::Value **Result=nullptr)
EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints as EmitStoreThroughLValue.
Definition: CGExpr.cpp:1933
The collection of all-type qualifiers we support.
Definition: Type.h:152
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:1419
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3478
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Definition: DeclCXX.h:1279
uint64_t getPointerWidth(unsigned AddrSpace) const
Return the width of pointers on this target, for the specified address space.
Definition: TargetInfo.h:311
const TargetInfo & getTarget() const
An object to manage conditionally-evaluated expressions.
IsDestructed_t isExternallyDestructed() const
Definition: CGValue.h:526
Expr * GetTemporaryExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue...
Definition: ExprCXX.h:4076
Address getAddress() const
Definition: CGValue.h:324
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:149
llvm::Value * EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE)
Definition: CGExprCXX.cpp:2124
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
Definition: CGExpr.cpp:531
field_range fields() const
Definition: Decl.h:3609
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2457
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:4400
An RAII object to set (and then clear) a mapping for an OpaqueValueExpr.
bool isReferenceType() const
Definition: Type.h:5956
bool hasTrivialMoveAssignment() const
Determine whether this class has a trivial move assignment operator (C++11 [class.copy]p25)
Definition: DeclCXX.h:1389
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
Definition: EHScopeStack.h:81
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Definition: CharUnits.h:53
Expr * getSubExpr()
Definition: Expr.h:2761
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:372
bool hadArrayRangeDesignator() const
Definition: Expr.h:4040
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:274
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:173
bool isGLValue() const
Definition: Expr.h:252
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:2122
Describes an C or C++ initializer list.
Definition: Expr.h:3872
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:638
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:1731
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:157
CharUnits - This is an opaque type for sizes expressed in character units.
Definition: CharUnits.h:38
CharUnits getAlignment() const
Return the alignment of this pointer.
Definition: Address.h:67
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2985
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:5790
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:1439
llvm::CallInst * CreateMemCpy(Address Dest, Address Src, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:259
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:39
field_iterator field_begin() const
Definition: Decl.cpp:3937
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:161
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:2710
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1196
bool isSimple() const
Definition: CGValue.h:249
RValue EmitAtomicExpr(AtomicExpr *E)
Definition: CGAtomic.cpp:742
CXXTemporary * getTemporary()
Definition: ExprCXX.h:1215
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1580
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:94
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
Definition: CGValue.h:71
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1042
Checking the operand of a load. Must be suitably sized and aligned.
const Expr * getExpr() const
Get the initialization expression that will be used.
Definition: ExprCXX.h:1141
RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())
Definition: CGObjC.cpp:355
bool hasAttr() const
Definition: DeclBase.h:535
bool isValid() const
Definition: Address.h:36
void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest)
Definition: CGExprCXX.cpp:556
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:39
InitListExpr * getUpdater() const
Definition: Expr.h:4458
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition: CharUnits.h:179
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:3778
bool isPointerZeroInitializable(QualType T)
Check if the pointer type can be zero-initialized (in the C++ sense) with an LLVM zeroinitializer...
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:2942
static TypeEvaluationKind getEvaluationKind(QualType T)
getEvaluationKind - Return the TypeEvaluationKind of QualType T.
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:1802
Expr - This represents one expression.
Definition: Expr.h:106
static Address invalid()
Definition: Address.h:35
Qualifiers getQualifiers() const
Definition: CGValue.h:533
Enters a new scope for capturing cleanups, all of which will be executed once the scope is exited...
const FunctionProtoType * T
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6370
Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
EmitCompoundStmt - Emit a compound statement {..} node.
Definition: CGStmt.cpp:363
unsigned getNumInits() const
Definition: Expr.h:3902
Expr * getSubExpr() const
Get the initializer to use for each array element.
Definition: Expr.h:4512
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:3612
llvm::PointerType * getType() const
Return the type of the pointer value.
Definition: Address.h:44
bool isAnyComplexType() const
Definition: Type.h:6025
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:128
void EmitLambdaExpr(const LambdaExpr *E, AggValueSlot Dest)
Definition: CGExprCXX.cpp:2207
An RAII object to record that we&#39;re evaluating a statement expression.
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
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:903
llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)
Definition: CGBuilder.h:281
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:1717
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:3838
bool hasTrivialCopyConstructor() const
Determine whether this class has a trivial copy constructor (C++ [class.copy]p6, C++11 [class...
Definition: DeclCXX.h:1348
const Expr * getSubExpr() const
Definition: Expr.h:1681
const Expr * getSubExpr() const
Definition: ExprCXX.h:1219
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:495
RValue EmitAtomicLoad(LValue LV, SourceLocation SL, AggValueSlot Slot=AggValueSlot::ignored())
Definition: CGAtomic.cpp:1449
RecordDecl * getDecl() const
Definition: Type.h:3988
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:868
Address CreateBitCast(Address Addr, llvm::Type *Ty, const llvm::Twine &Name="")
Definition: CGBuilder.h:142
Expr * getBase() const
Definition: Expr.h:4455
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1400
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:4969
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:1486
bool inheritedFromVBase() const
Determine whether the inherited constructor is inherited from a virtual base of the object we constru...
Definition: ExprCXX.h:1449
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:1376
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:1436
A saved depth on the scope stack.
Definition: EHScopeStack.h:107
Expr * getSubExpr() const
Definition: Expr.h:1744
LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK)
Same as EmitLValue but additionally we generate checking code to guard against undefined behavior...
Definition: CGExpr.cpp:1134
CastKind getCastKind() const
Definition: Expr.h:2757
LValue EmitAggExprToLValue(const Expr *E)
EmitAggExprToLValue - Emit the computation of the specified expression of aggregate type into a tempo...
Definition: CGExprAgg.cpp:1534
void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
DeactivateCleanupBlock - Deactivates the given cleanup block.
Definition: CGCleanup.cpp:1230
An aggregate value slot.
Definition: CGValue.h:434
A scoped helper to set the current debug location to the specified location or preferred location of ...
Definition: CGDebugInfo.h:620
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2321
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:186
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:5103
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:1260
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:1477
An aligned address.
Definition: Address.h:25
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after...
Definition: Type.h:1098
LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E)
Definition: CGExpr.cpp:4623
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3488
QualType getType() const
Definition: CGValue.h:261
RValue EmitCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue=ReturnValueSlot())
Definition: CGExpr.cpp:4177
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:3966
void enterFullExpression(const ExprWithCleanups *E)
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2214
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:216
const Expr * getInitializer() const
Definition: Expr.h:2663
Expr * getLHS() const
Definition: Expr.h:3029
void setExternallyDestructed(bool destructed=true)
Definition: CGValue.h:529
Represents a C11 generic selection.
Definition: Expr.h:4684
llvm::Value * EmitScalarExpr(const Expr *E, bool IgnoreResultAssign=false)
EmitScalarExpr - Emit the computation of the specified expression of LLVM scalar type, returning the result.
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn&#39;t support the specified stmt yet.
void setVolatile(bool flag)
Definition: CGValue.h:539
Dataflow Directional Tag Classes.
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1188
static AggValueSlot ignored()
ignored - Returns an aggregate value slot indicating that the aggregate value is being ignored...
Definition: CGValue.h:480
Address CreateStructGEP(Address Addr, unsigned Index, CharUnits Offset, const llvm::Twine &Name="")
Definition: CGBuilder.h:172
A scope within which we are constructing the fields of an object which might use a CXXDefaultInitExpr...
llvm::LoadInst * CreateAlignedLoad(llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition: CGBuilder.h:91
LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e)
Definition: CGExpr.cpp:4751
bool hasUserDeclaredConstructor() const
Determine whether this class has any user-declared constructors.
Definition: DeclCXX.h:936
Represents a &#39;co_yield&#39; expression.
Definition: ExprCXX.h:4387
const Expr * getExpr() const
Definition: ExprCXX.h:1077
U cast(CodeGen::Address addr)
Definition: Address.h:109
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.
void EmitAggregateCopy(Address DestPtr, Address SrcPtr, QualType EltTy, bool isVolatile=false, bool isAssignment=false)
EmitAggregateCopy - Emit an aggregate copy.
Definition: CGExprAgg.cpp:1544
bool isBitField() const
Definition: CGValue.h:251
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition: CGBuilder.h:108
llvm::Module & getModule() const
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
Definition: Expr.cpp:1307
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:1596
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type. ...
Definition: CGExprAgg.cpp:1522
void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)
Emit type info if type of an expression is a variably modified type.
Definition: CGExpr.cpp:951
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:3978
const LValue & getOpaqueLValueMapping(const OpaqueValueExpr *e)
getOpaqueLValueMapping - Given an opaque value expression (which must be mapped to an l-value)...
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2121
CodeGenTypes & getTypes() const
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Definition: Expr.h:3227
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Definition: Address.h:52
const llvm::APInt & getSize() const
Definition: Type.h:2638
bool isAtomicType() const
Definition: Type.h:6054
Represents a &#39;co_await&#39; expression.
Definition: ExprCXX.h:4304
llvm::Value * getAggregatePointer() const
Definition: CGValue.h:76
void EmitScalarInit(const Expr *init, const ValueDecl *D, LValue lvalue, bool capturedByInit)
Definition: CGDecl.cpp:713
bool hasSameType(QualType T1, QualType T2) const
Determine whether the given types T1 and T2 are equivalent.
Definition: ASTContext.h:2190
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition: Linkage.h:33
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition: CGStmt.cpp:436
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:513
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1113
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
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:2387
void ErrorUnsupported(const Stmt *S, const char *Type)
ErrorUnsupported - Print out an error that codegen doesn&#39;t support the specified stmt yet...
Represents a C++ struct/union/class.
Definition: DeclCXX.h:299
Represents a loop initializing the elements of an array.
Definition: Expr.h:4490
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:3664
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:1170
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1509
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2209
bool hasVolatileMember(QualType T)
hasVolatileMember - returns true if aggregate type has a volatile member.
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:956
static RValue get(llvm::Value *V)
Definition: CGValue.h:86
bool isUnion() const
Definition: Decl.h:3155
Expr * getRHS() const
Definition: Expr.h:3031
bool hasObjectMember() const
Definition: Decl.h:3551
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:3984
static RValue getAggregate(Address addr, bool isVolatile=false)
Definition: CGValue.h:107
LValue - This represents an lvalue references.
Definition: CGValue.h:167
RValue asRValue() const
Definition: CGValue.h:571
const LangOptions & getLangOpts() const
llvm::APInt getArraySize() const
Definition: Expr.h:4514
llvm::Value * getPointer() const
Definition: CGValue.h:320
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2620
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:4580
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
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:1714
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
IgnoreParens - Ignore parentheses.
Definition: Expr.cpp:2434
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.