blob: b1ac731f21342d589634437322f83497e1badea5 [file] [log] [blame]
Chris Lattner566b6ce2007-08-24 02:22:53 +00001//===--- CGExprAgg.cpp - Emit LLVM Code from Aggregate Expressions --------===//
Chris Lattneraf6f5282007-08-10 20:13:28 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattneraf6f5282007-08-10 20:13:28 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Aggregate Expr nodes as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
Chris Lattner883f6a72007-08-11 00:04:45 +000015#include "CodeGenModule.h"
Fariborz Jahanian082b02e2009-07-08 01:18:33 +000016#include "CGObjCRuntime.h"
Daniel Dunbarde7fb842008-08-11 05:00:27 +000017#include "clang/AST/ASTContext.h"
Anders Carlssonb14095a2009-04-17 00:06:03 +000018#include "clang/AST/DeclCXX.h"
Daniel Dunbarde7fb842008-08-11 05:00:27 +000019#include "clang/AST/StmtVisitor.h"
Chris Lattner883f6a72007-08-11 00:04:45 +000020#include "llvm/Constants.h"
21#include "llvm/Function.h"
Devang Patel636c3d02007-10-26 17:44:44 +000022#include "llvm/GlobalVariable.h"
Chris Lattnerf81557c2008-04-04 18:42:16 +000023#include "llvm/Intrinsics.h"
Chris Lattneraf6f5282007-08-10 20:13:28 +000024using namespace clang;
25using namespace CodeGen;
Chris Lattner883f6a72007-08-11 00:04:45 +000026
Chris Lattner9c033562007-08-21 04:25:47 +000027//===----------------------------------------------------------------------===//
28// Aggregate Expression Emitter
29//===----------------------------------------------------------------------===//
30
31namespace {
Benjamin Kramer85b45212009-11-28 19:45:26 +000032class AggExprEmitter : public StmtVisitor<AggExprEmitter> {
Chris Lattner9c033562007-08-21 04:25:47 +000033 CodeGenFunction &CGF;
Daniel Dunbar45d196b2008-11-01 01:53:16 +000034 CGBuilderTy &Builder;
John McCall558d2ab2010-09-15 10:14:12 +000035 AggValueSlot Dest;
Mike Stump49d1cd52009-05-26 22:03:21 +000036 bool IgnoreResult;
John McCallef072fd2010-05-22 01:48:05 +000037
38 ReturnValueSlot getReturnValueSlot() const {
John McCallfa037bd2010-05-22 22:13:32 +000039 // If the destination slot requires garbage collection, we can't
40 // use the real return value slot, because we have to use the GC
41 // API.
John McCalld1a5f132010-09-16 03:13:23 +000042 if (Dest.requiresGCollection()) return ReturnValueSlot();
John McCallfa037bd2010-05-22 22:13:32 +000043
John McCall558d2ab2010-09-15 10:14:12 +000044 return ReturnValueSlot(Dest.getAddr(), Dest.isVolatile());
45 }
46
47 AggValueSlot EnsureSlot(QualType T) {
48 if (!Dest.isIgnored()) return Dest;
49 return CGF.CreateAggTemp(T, "agg.tmp.ensured");
John McCallef072fd2010-05-22 01:48:05 +000050 }
John McCallfa037bd2010-05-22 22:13:32 +000051
Chris Lattner9c033562007-08-21 04:25:47 +000052public:
John McCall558d2ab2010-09-15 10:14:12 +000053 AggExprEmitter(CodeGenFunction &cgf, AggValueSlot Dest,
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +000054 bool ignore)
John McCall558d2ab2010-09-15 10:14:12 +000055 : CGF(cgf), Builder(CGF.Builder), Dest(Dest),
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +000056 IgnoreResult(ignore) {
Chris Lattner9c033562007-08-21 04:25:47 +000057 }
58
Chris Lattneree755f92007-08-21 04:59:27 +000059 //===--------------------------------------------------------------------===//
60 // Utilities
61 //===--------------------------------------------------------------------===//
62
Chris Lattner9c033562007-08-21 04:25:47 +000063 /// EmitAggLoadOfLValue - Given an expression with aggregate type that
64 /// represents a value lvalue, this method emits the address of the lvalue,
65 /// then loads the result into DestPtr.
66 void EmitAggLoadOfLValue(const Expr *E);
Eli Friedman922696f2008-05-19 17:51:16 +000067
Mike Stump4ac20dd2009-05-23 20:28:01 +000068 /// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
Mike Stump49d1cd52009-05-26 22:03:21 +000069 void EmitFinalDestCopy(const Expr *E, LValue Src, bool Ignore = false);
70 void EmitFinalDestCopy(const Expr *E, RValue Src, bool Ignore = false);
Mike Stump4ac20dd2009-05-23 20:28:01 +000071
John McCallfa037bd2010-05-22 22:13:32 +000072 void EmitGCMove(const Expr *E, RValue Src);
73
74 bool TypeRequiresGCollection(QualType T);
75
Chris Lattneree755f92007-08-21 04:59:27 +000076 //===--------------------------------------------------------------------===//
77 // Visitor Methods
78 //===--------------------------------------------------------------------===//
Mike Stump1eb44332009-09-09 15:08:12 +000079
Chris Lattner9c033562007-08-21 04:25:47 +000080 void VisitStmt(Stmt *S) {
Daniel Dunbar488e9932008-08-16 00:56:44 +000081 CGF.ErrorUnsupported(S, "aggregate expression");
Chris Lattner9c033562007-08-21 04:25:47 +000082 }
83 void VisitParenExpr(ParenExpr *PE) { Visit(PE->getSubExpr()); }
Peter Collingbournef111d932011-04-15 00:35:48 +000084 void VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
85 Visit(GE->getResultExpr());
86 }
Eli Friedman12444a22009-01-27 09:03:41 +000087 void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
Chris Lattner9c033562007-08-21 04:25:47 +000088
89 // l-values.
Seo Sanghyeon9b73b392007-12-14 02:04:12 +000090 void VisitDeclRefExpr(DeclRefExpr *DRE) { EmitAggLoadOfLValue(DRE); }
91 void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }
92 void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
Daniel Dunbar5be028f2010-01-04 18:47:06 +000093 void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }
Douglas Gregor751ec9b2011-06-17 04:59:12 +000094 void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
Seo Sanghyeon9b73b392007-12-14 02:04:12 +000095 void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
96 EmitAggLoadOfLValue(E);
97 }
Chris Lattnerf0a990c2009-04-21 23:00:09 +000098 void VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) {
Mike Stump1eb44332009-09-09 15:08:12 +000099 EmitAggLoadOfLValue(E);
Chris Lattnerf0a990c2009-04-21 23:00:09 +0000100 }
101 void VisitPredefinedExpr(const PredefinedExpr *E) {
Mike Stump1eb44332009-09-09 15:08:12 +0000102 EmitAggLoadOfLValue(E);
Chris Lattnerf0a990c2009-04-21 23:00:09 +0000103 }
Mike Stump1eb44332009-09-09 15:08:12 +0000104
Chris Lattner9c033562007-08-21 04:25:47 +0000105 // Operators.
Anders Carlsson4d8673b2009-08-07 23:22:37 +0000106 void VisitCastExpr(CastExpr *E);
Anders Carlsson148fe672007-10-31 22:04:46 +0000107 void VisitCallExpr(const CallExpr *E);
Chris Lattnerb2d963f2007-08-31 22:54:14 +0000108 void VisitStmtExpr(const StmtExpr *E);
Chris Lattner9c033562007-08-21 04:25:47 +0000109 void VisitBinaryOperator(const BinaryOperator *BO);
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +0000110 void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO);
Chris Lattner03d6fb92007-08-21 04:43:17 +0000111 void VisitBinAssign(const BinaryOperator *E);
Eli Friedman07fa52a2008-05-20 07:56:31 +0000112 void VisitBinComma(const BinaryOperator *E);
Chris Lattner9c033562007-08-21 04:25:47 +0000113
Chris Lattner8fdf3282008-06-24 17:04:18 +0000114 void VisitObjCMessageExpr(ObjCMessageExpr *E);
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000115 void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
116 EmitAggLoadOfLValue(E);
117 }
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000118 void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
Mike Stump1eb44332009-09-09 15:08:12 +0000119
John McCall56ca35d2011-02-17 10:25:35 +0000120 void VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
Anders Carlssona294ca82009-07-08 18:33:14 +0000121 void VisitChooseExpr(const ChooseExpr *CE);
Devang Patel636c3d02007-10-26 17:44:44 +0000122 void VisitInitListExpr(InitListExpr *E);
Anders Carlsson30311fa2009-12-16 06:57:54 +0000123 void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
Chris Lattner04421082008-04-08 04:40:51 +0000124 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
125 Visit(DAE->getExpr());
126 }
Anders Carlssonb58d0172009-05-30 23:23:33 +0000127 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
Anders Carlsson31ccf372009-05-03 17:47:16 +0000128 void VisitCXXConstructExpr(const CXXConstructExpr *E);
John McCall4765fa02010-12-06 08:20:24 +0000129 void VisitExprWithCleanups(ExprWithCleanups *E);
Douglas Gregored8abf12010-07-08 06:14:04 +0000130 void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
Mike Stump2710c412009-11-18 00:40:12 +0000131 void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); }
Anders Carlsson7f6ad152009-05-19 04:48:36 +0000132
John McCalle996ffd2011-02-16 08:02:54 +0000133 void VisitOpaqueValueExpr(OpaqueValueExpr *E);
134
Eli Friedmanb1851242008-05-27 15:51:49 +0000135 void VisitVAArgExpr(VAArgExpr *E);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000136
John McCalla07398e2011-06-16 04:16:24 +0000137 void EmitInitializationToLValue(Expr *E, LValue Address);
138 void EmitNullInitializationToLValue(LValue Address);
Chris Lattner9c033562007-08-21 04:25:47 +0000139 // case Expr::ChooseExprClass:
Mike Stump39406b12009-12-09 19:24:08 +0000140 void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
Chris Lattner9c033562007-08-21 04:25:47 +0000141};
142} // end anonymous namespace.
143
Chris Lattneree755f92007-08-21 04:59:27 +0000144//===----------------------------------------------------------------------===//
145// Utilities
146//===----------------------------------------------------------------------===//
Chris Lattner9c033562007-08-21 04:25:47 +0000147
Chris Lattner883f6a72007-08-11 00:04:45 +0000148/// EmitAggLoadOfLValue - Given an expression with aggregate type that
149/// represents a value lvalue, this method emits the address of the lvalue,
150/// then loads the result into DestPtr.
Chris Lattner9c033562007-08-21 04:25:47 +0000151void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
152 LValue LV = CGF.EmitLValue(E);
Mike Stump4ac20dd2009-05-23 20:28:01 +0000153 EmitFinalDestCopy(E, LV);
154}
155
John McCallfa037bd2010-05-22 22:13:32 +0000156/// \brief True if the given aggregate type requires special GC API calls.
157bool AggExprEmitter::TypeRequiresGCollection(QualType T) {
158 // Only record types have members that might require garbage collection.
159 const RecordType *RecordTy = T->getAs<RecordType>();
160 if (!RecordTy) return false;
161
162 // Don't mess with non-trivial C++ types.
163 RecordDecl *Record = RecordTy->getDecl();
164 if (isa<CXXRecordDecl>(Record) &&
165 (!cast<CXXRecordDecl>(Record)->hasTrivialCopyConstructor() ||
166 !cast<CXXRecordDecl>(Record)->hasTrivialDestructor()))
167 return false;
168
169 // Check whether the type has an object member.
170 return Record->hasObjectMember();
171}
172
173/// \brief Perform the final move to DestPtr if RequiresGCollection is set.
174///
175/// The idea is that you do something like this:
176/// RValue Result = EmitSomething(..., getReturnValueSlot());
177/// EmitGCMove(E, Result);
178/// If GC doesn't interfere, this will cause the result to be emitted
179/// directly into the return value slot. If GC does interfere, a final
180/// move will be performed.
181void AggExprEmitter::EmitGCMove(const Expr *E, RValue Src) {
John McCalld1a5f132010-09-16 03:13:23 +0000182 if (Dest.requiresGCollection()) {
Ken Dyck479b61c2011-04-24 17:08:00 +0000183 CharUnits size = CGF.getContext().getTypeSizeInChars(E->getType());
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000184 const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
Ken Dyck479b61c2011-04-24 17:08:00 +0000185 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size.getQuantity());
John McCall558d2ab2010-09-15 10:14:12 +0000186 CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF, Dest.getAddr(),
John McCallfa037bd2010-05-22 22:13:32 +0000187 Src.getAggregateAddr(),
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000188 SizeVal);
189 }
John McCallfa037bd2010-05-22 22:13:32 +0000190}
191
Mike Stump4ac20dd2009-05-23 20:28:01 +0000192/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
Mike Stump49d1cd52009-05-26 22:03:21 +0000193void AggExprEmitter::EmitFinalDestCopy(const Expr *E, RValue Src, bool Ignore) {
Mike Stump4ac20dd2009-05-23 20:28:01 +0000194 assert(Src.isAggregate() && "value must be aggregate value!");
195
John McCall558d2ab2010-09-15 10:14:12 +0000196 // If Dest is ignored, then we're evaluating an aggregate expression
John McCalla8f28da2010-08-25 02:50:31 +0000197 // in a context (like an expression statement) that doesn't care
198 // about the result. C says that an lvalue-to-rvalue conversion is
199 // performed in these cases; C++ says that it is not. In either
200 // case, we don't actually need to do anything unless the value is
201 // volatile.
John McCall558d2ab2010-09-15 10:14:12 +0000202 if (Dest.isIgnored()) {
John McCalla8f28da2010-08-25 02:50:31 +0000203 if (!Src.isVolatileQualified() ||
204 CGF.CGM.getLangOptions().CPlusPlus ||
205 (IgnoreResult && Ignore))
Mike Stump9ccb1032009-05-23 22:01:27 +0000206 return;
Fariborz Jahanian8a970052010-10-22 22:05:03 +0000207
Mike Stump49d1cd52009-05-26 22:03:21 +0000208 // If the source is volatile, we must read from it; to do that, we need
209 // some place to put it.
John McCall558d2ab2010-09-15 10:14:12 +0000210 Dest = CGF.CreateAggTemp(E->getType(), "agg.tmp");
Mike Stump9ccb1032009-05-23 22:01:27 +0000211 }
Chris Lattner883f6a72007-08-11 00:04:45 +0000212
John McCalld1a5f132010-09-16 03:13:23 +0000213 if (Dest.requiresGCollection()) {
Ken Dyck479b61c2011-04-24 17:08:00 +0000214 CharUnits size = CGF.getContext().getTypeSizeInChars(E->getType());
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000215 const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
Ken Dyck479b61c2011-04-24 17:08:00 +0000216 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size.getQuantity());
Fariborz Jahanian08c32132009-08-31 19:33:16 +0000217 CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF,
John McCall558d2ab2010-09-15 10:14:12 +0000218 Dest.getAddr(),
219 Src.getAggregateAddr(),
220 SizeVal);
Fariborz Jahanian08c32132009-08-31 19:33:16 +0000221 return;
222 }
Mike Stump4ac20dd2009-05-23 20:28:01 +0000223 // If the result of the assignment is used, copy the LHS there also.
224 // FIXME: Pass VolatileDest as well. I think we also need to merge volatile
225 // from the source as well, as we can't eliminate it if either operand
226 // is volatile, unless copy has volatile for both source and destination..
John McCall558d2ab2010-09-15 10:14:12 +0000227 CGF.EmitAggregateCopy(Dest.getAddr(), Src.getAggregateAddr(), E->getType(),
228 Dest.isVolatile()|Src.isVolatileQualified());
Mike Stump4ac20dd2009-05-23 20:28:01 +0000229}
230
231/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
Mike Stump49d1cd52009-05-26 22:03:21 +0000232void AggExprEmitter::EmitFinalDestCopy(const Expr *E, LValue Src, bool Ignore) {
Mike Stump4ac20dd2009-05-23 20:28:01 +0000233 assert(Src.isSimple() && "Can't have aggregate bitfield, vector, etc");
234
235 EmitFinalDestCopy(E, RValue::getAggregate(Src.getAddress(),
Mike Stump49d1cd52009-05-26 22:03:21 +0000236 Src.isVolatileQualified()),
237 Ignore);
Chris Lattner883f6a72007-08-11 00:04:45 +0000238}
239
Chris Lattneree755f92007-08-21 04:59:27 +0000240//===----------------------------------------------------------------------===//
241// Visitor Methods
242//===----------------------------------------------------------------------===//
243
John McCalle996ffd2011-02-16 08:02:54 +0000244void AggExprEmitter::VisitOpaqueValueExpr(OpaqueValueExpr *e) {
John McCall56ca35d2011-02-17 10:25:35 +0000245 EmitFinalDestCopy(e, CGF.getOpaqueLValueMapping(e));
John McCalle996ffd2011-02-16 08:02:54 +0000246}
247
Douglas Gregor751ec9b2011-06-17 04:59:12 +0000248void
249AggExprEmitter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
Douglas Gregor673e98b2011-06-17 16:37:20 +0000250 if (E->getType().isPODType(CGF.getContext())) {
251 // For a POD type, just emit a load of the lvalue + a copy, because our
252 // compound literal might alias the destination.
253 // FIXME: This is a band-aid; the real problem appears to be in our handling
254 // of assignments, where we store directly into the LHS without checking
255 // whether anything in the RHS aliases.
256 EmitAggLoadOfLValue(E);
257 return;
258 }
259
Douglas Gregor751ec9b2011-06-17 04:59:12 +0000260 AggValueSlot Slot = EnsureSlot(E->getType());
261 CGF.EmitAggExpr(E->getInitializer(), Slot);
262}
263
264
Anders Carlsson4d8673b2009-08-07 23:22:37 +0000265void AggExprEmitter::VisitCastExpr(CastExpr *E) {
Anders Carlsson30168422009-09-29 01:23:39 +0000266 switch (E->getCastKind()) {
Anders Carlsson575b3742011-04-11 02:03:26 +0000267 case CK_Dynamic: {
Douglas Gregor69cfeb12010-05-14 21:31:02 +0000268 assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?");
269 LValue LV = CGF.EmitCheckedLValue(E->getSubExpr());
270 // FIXME: Do we also need to handle property references here?
271 if (LV.isSimple())
272 CGF.EmitDynamicCast(LV.getAddress(), cast<CXXDynamicCastExpr>(E));
273 else
274 CGF.CGM.ErrorUnsupported(E, "non-simple lvalue dynamic_cast");
275
John McCall558d2ab2010-09-15 10:14:12 +0000276 if (!Dest.isIgnored())
277 CGF.CGM.ErrorUnsupported(E, "lvalue dynamic_cast with a destination");
Douglas Gregor69cfeb12010-05-14 21:31:02 +0000278 break;
279 }
280
John McCall2de56d12010-08-25 11:45:40 +0000281 case CK_ToUnion: {
John McCall65912712011-04-12 22:02:02 +0000282 if (Dest.isIgnored()) break;
283
Anders Carlsson4d8673b2009-08-07 23:22:37 +0000284 // GCC union extension
Daniel Dunbar79c39282010-08-21 03:15:20 +0000285 QualType Ty = E->getSubExpr()->getType();
286 QualType PtrTy = CGF.getContext().getPointerType(Ty);
John McCall558d2ab2010-09-15 10:14:12 +0000287 llvm::Value *CastPtr = Builder.CreateBitCast(Dest.getAddr(),
Eli Friedman34ebf4d2009-06-03 20:45:06 +0000288 CGF.ConvertType(PtrTy));
John McCalla07398e2011-06-16 04:16:24 +0000289 EmitInitializationToLValue(E->getSubExpr(),
290 CGF.MakeAddrLValue(CastPtr, Ty));
Anders Carlsson30168422009-09-29 01:23:39 +0000291 break;
Nuno Lopes7e916272009-01-15 20:14:33 +0000292 }
Mike Stump1eb44332009-09-09 15:08:12 +0000293
John McCall2de56d12010-08-25 11:45:40 +0000294 case CK_DerivedToBase:
295 case CK_BaseToDerived:
296 case CK_UncheckedDerivedToBase: {
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000297 assert(0 && "cannot perform hierarchy conversion in EmitAggExpr: "
298 "should have been unpacked before we got here");
299 break;
300 }
301
John McCallf6a16482010-12-04 03:47:34 +0000302 case CK_GetObjCProperty: {
303 LValue LV = CGF.EmitLValue(E->getSubExpr());
304 assert(LV.isPropertyRef());
305 RValue RV = CGF.EmitLoadOfPropertyRefLValue(LV, getReturnValueSlot());
306 EmitGCMove(E, RV);
307 break;
308 }
309
310 case CK_LValueToRValue: // hope for downstream optimization
John McCall2de56d12010-08-25 11:45:40 +0000311 case CK_NoOp:
312 case CK_UserDefinedConversion:
313 case CK_ConstructorConversion:
Anders Carlsson30168422009-09-29 01:23:39 +0000314 assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(),
315 E->getType()) &&
316 "Implicit cast types must be compatible");
317 Visit(E->getSubExpr());
318 break;
John McCall0ae287a2010-12-01 04:43:34 +0000319
John McCall2de56d12010-08-25 11:45:40 +0000320 case CK_LValueBitCast:
John McCall0ae287a2010-12-01 04:43:34 +0000321 llvm_unreachable("should not be emitting lvalue bitcast as rvalue");
Douglas Gregore39a3892010-07-13 23:17:26 +0000322 break;
John McCall1de4d4e2011-04-07 08:22:57 +0000323
John McCall0ae287a2010-12-01 04:43:34 +0000324 case CK_Dependent:
325 case CK_BitCast:
326 case CK_ArrayToPointerDecay:
327 case CK_FunctionToPointerDecay:
328 case CK_NullToPointer:
329 case CK_NullToMemberPointer:
330 case CK_BaseToDerivedMemberPointer:
331 case CK_DerivedToBaseMemberPointer:
332 case CK_MemberPointerToBoolean:
333 case CK_IntegralToPointer:
334 case CK_PointerToIntegral:
335 case CK_PointerToBoolean:
336 case CK_ToVoid:
337 case CK_VectorSplat:
338 case CK_IntegralCast:
339 case CK_IntegralToBoolean:
340 case CK_IntegralToFloating:
341 case CK_FloatingToIntegral:
342 case CK_FloatingToBoolean:
343 case CK_FloatingCast:
344 case CK_AnyPointerToObjCPointerCast:
345 case CK_AnyPointerToBlockPointerCast:
346 case CK_ObjCObjectLValueCast:
347 case CK_FloatingRealToComplex:
348 case CK_FloatingComplexToReal:
349 case CK_FloatingComplexToBoolean:
350 case CK_FloatingComplexCast:
351 case CK_FloatingComplexToIntegralComplex:
352 case CK_IntegralRealToComplex:
353 case CK_IntegralComplexToReal:
354 case CK_IntegralComplexToBoolean:
355 case CK_IntegralComplexCast:
356 case CK_IntegralComplexToFloatingComplex:
John McCallf85e1932011-06-15 23:02:42 +0000357 case CK_ObjCProduceObject:
358 case CK_ObjCConsumeObject:
John McCall0ae287a2010-12-01 04:43:34 +0000359 llvm_unreachable("cast kind invalid for aggregate types");
Anders Carlsson30168422009-09-29 01:23:39 +0000360 }
Anders Carlssone4707ff2008-01-14 06:28:57 +0000361}
362
Chris Lattner96196622008-07-26 22:37:01 +0000363void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
Anders Carlssone70e8f72009-05-27 16:45:02 +0000364 if (E->getCallReturnType()->isReferenceType()) {
365 EmitAggLoadOfLValue(E);
366 return;
367 }
Mike Stump1eb44332009-09-09 15:08:12 +0000368
John McCallfa037bd2010-05-22 22:13:32 +0000369 RValue RV = CGF.EmitCallExpr(E, getReturnValueSlot());
370 EmitGCMove(E, RV);
Anders Carlsson148fe672007-10-31 22:04:46 +0000371}
Chris Lattner96196622008-07-26 22:37:01 +0000372
373void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
John McCallfa037bd2010-05-22 22:13:32 +0000374 RValue RV = CGF.EmitObjCMessageExpr(E, getReturnValueSlot());
375 EmitGCMove(E, RV);
Chris Lattner8fdf3282008-06-24 17:04:18 +0000376}
Anders Carlsson148fe672007-10-31 22:04:46 +0000377
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000378void AggExprEmitter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
John McCallf6a16482010-12-04 03:47:34 +0000379 llvm_unreachable("direct property access not surrounded by "
380 "lvalue-to-rvalue cast");
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000381}
382
Chris Lattner96196622008-07-26 22:37:01 +0000383void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
John McCall2a416372010-12-05 02:00:02 +0000384 CGF.EmitIgnoredExpr(E->getLHS());
John McCall558d2ab2010-09-15 10:14:12 +0000385 Visit(E->getRHS());
Eli Friedman07fa52a2008-05-20 07:56:31 +0000386}
387
Chris Lattnerb2d963f2007-08-31 22:54:14 +0000388void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
John McCall150b4622011-01-26 04:00:11 +0000389 CodeGenFunction::StmtExprEvaluation eval(CGF);
John McCall558d2ab2010-09-15 10:14:12 +0000390 CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest);
Chris Lattnerb2d963f2007-08-31 22:54:14 +0000391}
392
Chris Lattner9c033562007-08-21 04:25:47 +0000393void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
John McCall2de56d12010-08-25 11:45:40 +0000394 if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI)
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +0000395 VisitPointerToDataMemberBinaryOperator(E);
396 else
397 CGF.ErrorUnsupported(E, "aggregate binary expression");
398}
399
400void AggExprEmitter::VisitPointerToDataMemberBinaryOperator(
401 const BinaryOperator *E) {
402 LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E);
403 EmitFinalDestCopy(E, LV);
Chris Lattneree755f92007-08-21 04:59:27 +0000404}
405
Chris Lattner03d6fb92007-08-21 04:43:17 +0000406void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
Eli Friedmanff6e2b72008-02-11 01:09:17 +0000407 // For an assignment to work, the value on the right has
408 // to be compatible with the value on the left.
Eli Friedman2dce5f82009-05-28 23:04:00 +0000409 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
410 E->getRHS()->getType())
Eli Friedmanff6e2b72008-02-11 01:09:17 +0000411 && "Invalid assignment");
John McCallcd940a12010-12-06 06:10:02 +0000412
Fariborz Jahanian2c7168c2011-04-29 21:53:21 +0000413 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->getLHS()))
Fariborz Jahanian73a6f8e2011-04-29 22:11:28 +0000414 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl()))
Fariborz Jahanian2c7168c2011-04-29 21:53:21 +0000415 if (VD->hasAttr<BlocksAttr>() &&
416 E->getRHS()->HasSideEffects(CGF.getContext())) {
417 // When __block variable on LHS, the RHS must be evaluated first
418 // as it may change the 'forwarding' field via call to Block_copy.
419 LValue RHS = CGF.EmitLValue(E->getRHS());
420 LValue LHS = CGF.EmitLValue(E->getLHS());
421 bool GCollection = false;
422 if (CGF.getContext().getLangOptions().getGCMode())
423 GCollection = TypeRequiresGCollection(E->getLHS()->getType());
Fariborz Jahanian2c7168c2011-04-29 21:53:21 +0000424 Dest = AggValueSlot::forLValue(LHS, true, GCollection);
425 EmitFinalDestCopy(E, RHS, true);
426 return;
427 }
Fariborz Jahanian2c7168c2011-04-29 21:53:21 +0000428
Chris Lattner9c033562007-08-21 04:25:47 +0000429 LValue LHS = CGF.EmitLValue(E->getLHS());
Chris Lattner883f6a72007-08-11 00:04:45 +0000430
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000431 // We have to special case property setters, otherwise we must have
432 // a simple lvalue (no aggregates inside vectors, bitfields).
433 if (LHS.isPropertyRef()) {
Fariborz Jahanian68af13f2011-03-30 16:11:20 +0000434 const ObjCPropertyRefExpr *RE = LHS.getPropertyRefExpr();
435 QualType ArgType = RE->getSetterArgType();
436 RValue Src;
437 if (ArgType->isReferenceType())
438 Src = CGF.EmitReferenceBindingToExpr(E->getRHS(), 0);
439 else {
440 AggValueSlot Slot = EnsureSlot(E->getRHS()->getType());
441 CGF.EmitAggExpr(E->getRHS(), Slot);
442 Src = Slot.asRValue();
443 }
444 CGF.EmitStoreThroughPropertyRefLValue(Src, LHS);
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000445 } else {
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000446 bool GCollection = false;
John McCallfa037bd2010-05-22 22:13:32 +0000447 if (CGF.getContext().getLangOptions().getGCMode())
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000448 GCollection = TypeRequiresGCollection(E->getLHS()->getType());
John McCallfa037bd2010-05-22 22:13:32 +0000449
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000450 // Codegen the RHS so that it stores directly into the LHS.
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000451 AggValueSlot LHSSlot = AggValueSlot::forLValue(LHS, true,
452 GCollection);
453 CGF.EmitAggExpr(E->getRHS(), LHSSlot, false);
Mike Stump49d1cd52009-05-26 22:03:21 +0000454 EmitFinalDestCopy(E, LHS, true);
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000455 }
Chris Lattner883f6a72007-08-11 00:04:45 +0000456}
457
John McCall56ca35d2011-02-17 10:25:35 +0000458void AggExprEmitter::
459VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
Daniel Dunbar9615ecb2008-11-13 01:38:36 +0000460 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
461 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
462 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
Mike Stump1eb44332009-09-09 15:08:12 +0000463
John McCall56ca35d2011-02-17 10:25:35 +0000464 // Bind the common expression if necessary.
465 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
466
John McCall150b4622011-01-26 04:00:11 +0000467 CodeGenFunction::ConditionalEvaluation eval(CGF);
Eli Friedman8e274bd2009-12-25 06:17:05 +0000468 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000469
John McCall74fb0ed2010-11-17 00:07:33 +0000470 // Save whether the destination's lifetime is externally managed.
471 bool DestLifetimeManaged = Dest.isLifetimeExternallyManaged();
Chris Lattner883f6a72007-08-11 00:04:45 +0000472
John McCall150b4622011-01-26 04:00:11 +0000473 eval.begin(CGF);
474 CGF.EmitBlock(LHSBlock);
John McCall56ca35d2011-02-17 10:25:35 +0000475 Visit(E->getTrueExpr());
John McCall150b4622011-01-26 04:00:11 +0000476 eval.end(CGF);
Mike Stump1eb44332009-09-09 15:08:12 +0000477
John McCall150b4622011-01-26 04:00:11 +0000478 assert(CGF.HaveInsertPoint() && "expression evaluation ended with no IP!");
479 CGF.Builder.CreateBr(ContBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000480
John McCall74fb0ed2010-11-17 00:07:33 +0000481 // If the result of an agg expression is unused, then the emission
482 // of the LHS might need to create a destination slot. That's fine
483 // with us, and we can safely emit the RHS into the same slot, but
484 // we shouldn't claim that its lifetime is externally managed.
485 Dest.setLifetimeExternallyManaged(DestLifetimeManaged);
486
John McCall150b4622011-01-26 04:00:11 +0000487 eval.begin(CGF);
488 CGF.EmitBlock(RHSBlock);
John McCall56ca35d2011-02-17 10:25:35 +0000489 Visit(E->getFalseExpr());
John McCall150b4622011-01-26 04:00:11 +0000490 eval.end(CGF);
Mike Stump1eb44332009-09-09 15:08:12 +0000491
Chris Lattner9c033562007-08-21 04:25:47 +0000492 CGF.EmitBlock(ContBlock);
Chris Lattner883f6a72007-08-11 00:04:45 +0000493}
Chris Lattneree755f92007-08-21 04:59:27 +0000494
Anders Carlssona294ca82009-07-08 18:33:14 +0000495void AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) {
496 Visit(CE->getChosenSubExpr(CGF.getContext()));
497}
498
Eli Friedmanb1851242008-05-27 15:51:49 +0000499void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
Daniel Dunbar07855702009-02-11 22:25:55 +0000500 llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr());
Anders Carlssonddf7cac2008-11-04 05:30:00 +0000501 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType());
502
Sebastian Redl0262f022009-01-09 21:09:38 +0000503 if (!ArgPtr) {
Anders Carlssonddf7cac2008-11-04 05:30:00 +0000504 CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
Sebastian Redl0262f022009-01-09 21:09:38 +0000505 return;
506 }
507
Daniel Dunbar79c39282010-08-21 03:15:20 +0000508 EmitFinalDestCopy(VE, CGF.MakeAddrLValue(ArgPtr, VE->getType()));
Eli Friedmanb1851242008-05-27 15:51:49 +0000509}
510
Anders Carlssonb58d0172009-05-30 23:23:33 +0000511void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000512 // Ensure that we have a slot, but if we already do, remember
513 // whether its lifetime was externally managed.
514 bool WasManaged = Dest.isLifetimeExternallyManaged();
515 Dest = EnsureSlot(E->getType());
516 Dest.setLifetimeExternallyManaged();
Mike Stump1eb44332009-09-09 15:08:12 +0000517
John McCall558d2ab2010-09-15 10:14:12 +0000518 Visit(E->getSubExpr());
Anders Carlssonb58d0172009-05-30 23:23:33 +0000519
John McCall558d2ab2010-09-15 10:14:12 +0000520 // Set up the temporary's destructor if its lifetime wasn't already
521 // being managed.
522 if (!WasManaged)
523 CGF.EmitCXXTemporary(E->getTemporary(), Dest.getAddr());
Anders Carlssonb58d0172009-05-30 23:23:33 +0000524}
525
Anders Carlssonb14095a2009-04-17 00:06:03 +0000526void
Anders Carlsson31ccf372009-05-03 17:47:16 +0000527AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000528 AggValueSlot Slot = EnsureSlot(E->getType());
529 CGF.EmitCXXConstructExpr(E, Slot);
Anders Carlsson7f6ad152009-05-19 04:48:36 +0000530}
531
John McCall4765fa02010-12-06 08:20:24 +0000532void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
533 CGF.EmitExprWithCleanups(E, Dest);
Anders Carlssonb14095a2009-04-17 00:06:03 +0000534}
535
Douglas Gregored8abf12010-07-08 06:14:04 +0000536void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000537 QualType T = E->getType();
538 AggValueSlot Slot = EnsureSlot(T);
John McCalla07398e2011-06-16 04:16:24 +0000539 EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T));
Anders Carlsson30311fa2009-12-16 06:57:54 +0000540}
541
542void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000543 QualType T = E->getType();
544 AggValueSlot Slot = EnsureSlot(T);
John McCalla07398e2011-06-16 04:16:24 +0000545 EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T));
Nuno Lopes329763b2009-10-18 15:18:11 +0000546}
547
Chris Lattner1b726772010-12-02 07:07:26 +0000548/// isSimpleZero - If emitting this value will obviously just cause a store of
549/// zero to memory, return true. This can return false if uncertain, so it just
550/// handles simple cases.
551static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {
Peter Collingbournef111d932011-04-15 00:35:48 +0000552 E = E->IgnoreParens();
553
Chris Lattner1b726772010-12-02 07:07:26 +0000554 // 0
555 if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
556 return IL->getValue() == 0;
557 // +0.0
558 if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E))
559 return FL->getValue().isPosZero();
560 // int()
561 if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) &&
562 CGF.getTypes().isZeroInitializable(E->getType()))
563 return true;
564 // (int*)0 - Null pointer expressions.
565 if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
566 return ICE->getCastKind() == CK_NullToPointer;
567 // '\0'
568 if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E))
569 return CL->getValue() == 0;
570
571 // Otherwise, hard case: conservatively return false.
572 return false;
573}
574
575
Anders Carlsson78e83f82010-02-03 17:33:16 +0000576void
John McCalla07398e2011-06-16 04:16:24 +0000577AggExprEmitter::EmitInitializationToLValue(Expr* E, LValue LV) {
578 QualType type = LV.getType();
Mike Stump7f79f9b2009-05-29 15:46:01 +0000579 // FIXME: Ignore result?
Chris Lattnerf81557c2008-04-04 18:42:16 +0000580 // FIXME: Are initializers affected by volatile?
Chris Lattner1b726772010-12-02 07:07:26 +0000581 if (Dest.isZeroed() && isSimpleZero(E, CGF)) {
582 // Storing "i32 0" to a zero'd memory location is a noop.
583 } else if (isa<ImplicitValueInitExpr>(E)) {
John McCalla07398e2011-06-16 04:16:24 +0000584 EmitNullInitializationToLValue(LV);
585 } else if (type->isReferenceType()) {
Anders Carlsson32f36ba2010-06-26 16:35:32 +0000586 RValue RV = CGF.EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
John McCalla07398e2011-06-16 04:16:24 +0000587 CGF.EmitStoreThroughLValue(RV, LV, type);
588 } else if (type->isAnyComplexType()) {
Douglas Gregor3498bdb2009-01-29 17:44:32 +0000589 CGF.EmitComplexExprIntoAddr(E, LV.getAddress(), false);
John McCalla07398e2011-06-16 04:16:24 +0000590 } else if (CGF.hasAggregateLLVMType(type)) {
591 CGF.EmitAggExpr(E, AggValueSlot::forLValue(LV, true, false,
592 Dest.isZeroed()));
John McCallf85e1932011-06-15 23:02:42 +0000593 } else if (LV.isSimple()) {
John McCalla07398e2011-06-16 04:16:24 +0000594 CGF.EmitScalarInit(E, /*D=*/0, LV, /*Captured=*/false);
Eli Friedmanc8ba9612008-05-12 15:06:05 +0000595 } else {
John McCalla07398e2011-06-16 04:16:24 +0000596 CGF.EmitStoreThroughLValue(RValue::get(CGF.EmitScalarExpr(E)), LV, type);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000597 }
Chris Lattnerf81557c2008-04-04 18:42:16 +0000598}
599
John McCalla07398e2011-06-16 04:16:24 +0000600void AggExprEmitter::EmitNullInitializationToLValue(LValue lv) {
601 QualType type = lv.getType();
602
Chris Lattner1b726772010-12-02 07:07:26 +0000603 // If the destination slot is already zeroed out before the aggregate is
604 // copied into it, we don't have to emit any zeros here.
John McCalla07398e2011-06-16 04:16:24 +0000605 if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(type))
Chris Lattner1b726772010-12-02 07:07:26 +0000606 return;
607
John McCalla07398e2011-06-16 04:16:24 +0000608 if (!CGF.hasAggregateLLVMType(type)) {
Chris Lattnerf81557c2008-04-04 18:42:16 +0000609 // For non-aggregates, we can store zero
John McCalla07398e2011-06-16 04:16:24 +0000610 llvm::Value *null = llvm::Constant::getNullValue(CGF.ConvertType(type));
611 CGF.EmitStoreThroughLValue(RValue::get(null), lv, type);
Lauro Ramos Venancio145cd892008-02-19 19:27:31 +0000612 } else {
Chris Lattnerf81557c2008-04-04 18:42:16 +0000613 // There's a potential optimization opportunity in combining
614 // memsets; that would be easy for arrays, but relatively
615 // difficult for structures with the current code.
John McCalla07398e2011-06-16 04:16:24 +0000616 CGF.EmitNullInitialization(lv.getAddress(), lv.getType());
Chris Lattnerf81557c2008-04-04 18:42:16 +0000617 }
618}
619
Chris Lattnerf81557c2008-04-04 18:42:16 +0000620void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
Eli Friedmana385b3c2008-12-02 01:17:45 +0000621#if 0
Eli Friedman13a5be12009-12-04 01:30:56 +0000622 // FIXME: Assess perf here? Figure out what cases are worth optimizing here
623 // (Length of globals? Chunks of zeroed-out space?).
Eli Friedmana385b3c2008-12-02 01:17:45 +0000624 //
Mike Stumpf5408fe2009-05-16 07:57:57 +0000625 // If we can, prefer a copy from a global; this is a lot less code for long
626 // globals, and it's easier for the current optimizers to analyze.
Eli Friedman13a5be12009-12-04 01:30:56 +0000627 if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) {
Eli Friedman994ffef2008-11-30 02:11:09 +0000628 llvm::GlobalVariable* GV =
Eli Friedman13a5be12009-12-04 01:30:56 +0000629 new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true,
630 llvm::GlobalValue::InternalLinkage, C, "");
Daniel Dunbar79c39282010-08-21 03:15:20 +0000631 EmitFinalDestCopy(E, CGF.MakeAddrLValue(GV, E->getType()));
Eli Friedman994ffef2008-11-30 02:11:09 +0000632 return;
633 }
Eli Friedmana385b3c2008-12-02 01:17:45 +0000634#endif
Chris Lattnerd0db03a2010-09-06 00:11:41 +0000635 if (E->hadArrayRangeDesignator())
Douglas Gregora9c87802009-01-29 19:42:23 +0000636 CGF.ErrorUnsupported(E, "GNU array range designator extension");
Douglas Gregora9c87802009-01-29 19:42:23 +0000637
John McCall558d2ab2010-09-15 10:14:12 +0000638 llvm::Value *DestPtr = Dest.getAddr();
639
Chris Lattnerf81557c2008-04-04 18:42:16 +0000640 // Handle initialization of an array.
641 if (E->getType()->isArrayType()) {
642 const llvm::PointerType *APType =
643 cast<llvm::PointerType>(DestPtr->getType());
644 const llvm::ArrayType *AType =
645 cast<llvm::ArrayType>(APType->getElementType());
Mike Stump1eb44332009-09-09 15:08:12 +0000646
Chris Lattnerf81557c2008-04-04 18:42:16 +0000647 uint64_t NumInitElements = E->getNumInits();
Eli Friedman922696f2008-05-19 17:51:16 +0000648
Chris Lattner96196622008-07-26 22:37:01 +0000649 if (E->getNumInits() > 0) {
650 QualType T1 = E->getType();
651 QualType T2 = E->getInit(0)->getType();
Eli Friedman2dce5f82009-05-28 23:04:00 +0000652 if (CGF.getContext().hasSameUnqualifiedType(T1, T2)) {
Chris Lattner96196622008-07-26 22:37:01 +0000653 EmitAggLoadOfLValue(E->getInit(0));
654 return;
655 }
Eli Friedman922696f2008-05-19 17:51:16 +0000656 }
657
Chris Lattnerf81557c2008-04-04 18:42:16 +0000658 uint64_t NumArrayElements = AType->getNumElements();
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000659 QualType ElementType = CGF.getContext().getCanonicalType(E->getType());
Douglas Gregor4c678342009-01-28 21:54:33 +0000660 ElementType = CGF.getContext().getAsArrayType(ElementType)->getElementType();
John McCallf85e1932011-06-15 23:02:42 +0000661 ElementType = CGF.getContext().getQualifiedType(ElementType,
662 Dest.getQualifiers());
Mike Stump1eb44332009-09-09 15:08:12 +0000663
Argyrios Kyrtzidis3b4d4902011-04-28 18:53:58 +0000664 bool hasNonTrivialCXXConstructor = false;
665 if (CGF.getContext().getLangOptions().CPlusPlus)
Argyrios Kyrtzidis49621532011-04-28 20:07:15 +0000666 if (const RecordType *RT = CGF.getContext()
667 .getBaseElementType(ElementType)->getAs<RecordType>()) {
Argyrios Kyrtzidis3b4d4902011-04-28 18:53:58 +0000668 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
Sean Hunt023df372011-05-09 18:22:59 +0000669 hasNonTrivialCXXConstructor = !RD->hasTrivialDefaultConstructor();
Argyrios Kyrtzidis3b4d4902011-04-28 18:53:58 +0000670 }
671
Chris Lattnerf81557c2008-04-04 18:42:16 +0000672 for (uint64_t i = 0; i != NumArrayElements; ++i) {
Chris Lattner1b726772010-12-02 07:07:26 +0000673 // If we're done emitting initializers and the destination is known-zeroed
674 // then we're done.
675 if (i == NumInitElements &&
676 Dest.isZeroed() &&
Argyrios Kyrtzidis3b4d4902011-04-28 18:53:58 +0000677 CGF.getTypes().isZeroInitializable(ElementType) &&
678 !hasNonTrivialCXXConstructor)
Chris Lattner1b726772010-12-02 07:07:26 +0000679 break;
680
Chris Lattnerf81557c2008-04-04 18:42:16 +0000681 llvm::Value *NextVal = Builder.CreateStructGEP(DestPtr, i, ".array");
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000682 LValue LV = CGF.MakeAddrLValue(NextVal, ElementType);
Chris Lattner1b726772010-12-02 07:07:26 +0000683
Chris Lattnerf81557c2008-04-04 18:42:16 +0000684 if (i < NumInitElements)
John McCalla07398e2011-06-16 04:16:24 +0000685 EmitInitializationToLValue(E->getInit(i), LV);
Argyrios Kyrtzidis4423ac02011-04-21 00:27:41 +0000686 else if (Expr *filler = E->getArrayFiller())
John McCalla07398e2011-06-16 04:16:24 +0000687 EmitInitializationToLValue(filler, LV);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000688 else
John McCalla07398e2011-06-16 04:16:24 +0000689 EmitNullInitializationToLValue(LV);
Chris Lattner1b726772010-12-02 07:07:26 +0000690
691 // If the GEP didn't get used because of a dead zero init or something
692 // else, clean it up for -O0 builds and general tidiness.
693 if (llvm::GetElementPtrInst *GEP =
694 dyn_cast<llvm::GetElementPtrInst>(NextVal))
695 if (GEP->use_empty())
696 GEP->eraseFromParent();
Lauro Ramos Venancio145cd892008-02-19 19:27:31 +0000697 }
Chris Lattnerf81557c2008-04-04 18:42:16 +0000698 return;
699 }
Mike Stump1eb44332009-09-09 15:08:12 +0000700
Chris Lattnerf81557c2008-04-04 18:42:16 +0000701 assert(E->getType()->isRecordType() && "Only support structs/unions here!");
Mike Stump1eb44332009-09-09 15:08:12 +0000702
Chris Lattnerf81557c2008-04-04 18:42:16 +0000703 // Do struct initialization; this code just sets each individual member
704 // to the approprate value. This makes bitfield support automatic;
705 // the disadvantage is that the generated code is more difficult for
706 // the optimizer, especially with bitfields.
707 unsigned NumInitElements = E->getNumInits();
Ted Kremenek6217b802009-07-29 21:53:49 +0000708 RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
Chris Lattnerbd7de382010-09-06 00:13:11 +0000709
Douglas Gregor0bb76892009-01-29 16:53:55 +0000710 if (E->getType()->isUnionType()) {
711 // Only initialize one field of a union. The field itself is
712 // specified by the initializer list.
713 if (!E->getInitializedFieldInUnion()) {
714 // Empty union; we have nothing to do.
Mike Stump1eb44332009-09-09 15:08:12 +0000715
Douglas Gregor0bb76892009-01-29 16:53:55 +0000716#ifndef NDEBUG
717 // Make sure that it's really an empty and not a failure of
718 // semantic analysis.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000719 for (RecordDecl::field_iterator Field = SD->field_begin(),
720 FieldEnd = SD->field_end();
Douglas Gregor0bb76892009-01-29 16:53:55 +0000721 Field != FieldEnd; ++Field)
722 assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
723#endif
724 return;
725 }
726
727 // FIXME: volatility
728 FieldDecl *Field = E->getInitializedFieldInUnion();
Douglas Gregor0bb76892009-01-29 16:53:55 +0000729
Chris Lattner1b726772010-12-02 07:07:26 +0000730 LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestPtr, Field, 0);
Douglas Gregor0bb76892009-01-29 16:53:55 +0000731 if (NumInitElements) {
732 // Store the initializer into the field
John McCalla07398e2011-06-16 04:16:24 +0000733 EmitInitializationToLValue(E->getInit(0), FieldLoc);
Douglas Gregor0bb76892009-01-29 16:53:55 +0000734 } else {
Chris Lattner1b726772010-12-02 07:07:26 +0000735 // Default-initialize to null.
John McCalla07398e2011-06-16 04:16:24 +0000736 EmitNullInitializationToLValue(FieldLoc);
Douglas Gregor0bb76892009-01-29 16:53:55 +0000737 }
738
739 return;
740 }
Mike Stump1eb44332009-09-09 15:08:12 +0000741
Chris Lattnerf81557c2008-04-04 18:42:16 +0000742 // Here we iterate over the fields; this makes it simpler to both
743 // default-initialize fields and skip over unnamed fields.
Chris Lattnerbd7de382010-09-06 00:13:11 +0000744 unsigned CurInitVal = 0;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000745 for (RecordDecl::field_iterator Field = SD->field_begin(),
746 FieldEnd = SD->field_end();
Douglas Gregor44b43212008-12-11 16:49:14 +0000747 Field != FieldEnd; ++Field) {
748 // We're done once we hit the flexible array member
749 if (Field->getType()->isIncompleteArrayType())
750 break;
751
Douglas Gregor34e79462009-01-28 23:36:17 +0000752 if (Field->isUnnamedBitfield())
Chris Lattnerf81557c2008-04-04 18:42:16 +0000753 continue;
Douglas Gregor34e79462009-01-28 23:36:17 +0000754
Chris Lattner1b726772010-12-02 07:07:26 +0000755 // Don't emit GEP before a noop store of zero.
756 if (CurInitVal == NumInitElements && Dest.isZeroed() &&
757 CGF.getTypes().isZeroInitializable(E->getType()))
758 break;
759
Eli Friedman1e692ac2008-06-13 23:01:12 +0000760 // FIXME: volatility
Anders Carlssone78ccb42010-02-03 19:13:55 +0000761 LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestPtr, *Field, 0);
Fariborz Jahanian14674ff2009-05-27 19:54:11 +0000762 // We never generate write-barries for initialized fields.
Daniel Dunbarea619172010-08-21 03:22:38 +0000763 FieldLoc.setNonGC(true);
Chris Lattner1b726772010-12-02 07:07:26 +0000764
Chris Lattnerf81557c2008-04-04 18:42:16 +0000765 if (CurInitVal < NumInitElements) {
Chris Lattnerb35baae2010-03-08 21:08:07 +0000766 // Store the initializer into the field.
John McCalla07398e2011-06-16 04:16:24 +0000767 EmitInitializationToLValue(E->getInit(CurInitVal++), FieldLoc);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000768 } else {
769 // We're out of initalizers; default-initialize to null
John McCalla07398e2011-06-16 04:16:24 +0000770 EmitNullInitializationToLValue(FieldLoc);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000771 }
Chris Lattner1b726772010-12-02 07:07:26 +0000772
773 // If the GEP didn't get used because of a dead zero init or something
774 // else, clean it up for -O0 builds and general tidiness.
775 if (FieldLoc.isSimple())
776 if (llvm::GetElementPtrInst *GEP =
777 dyn_cast<llvm::GetElementPtrInst>(FieldLoc.getAddress()))
778 if (GEP->use_empty())
779 GEP->eraseFromParent();
Lauro Ramos Venancio145cd892008-02-19 19:27:31 +0000780 }
Devang Patel636c3d02007-10-26 17:44:44 +0000781}
782
Chris Lattneree755f92007-08-21 04:59:27 +0000783//===----------------------------------------------------------------------===//
784// Entry Points into this File
785//===----------------------------------------------------------------------===//
786
Chris Lattner1b726772010-12-02 07:07:26 +0000787/// GetNumNonZeroBytesInInit - Get an approximate count of the number of
788/// non-zero bytes that will be stored when outputting the initializer for the
789/// specified initializer expression.
Ken Dyck02c45332011-04-24 17:17:56 +0000790static CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) {
Peter Collingbournef111d932011-04-15 00:35:48 +0000791 E = E->IgnoreParens();
Chris Lattner1b726772010-12-02 07:07:26 +0000792
793 // 0 and 0.0 won't require any non-zero stores!
Ken Dyck02c45332011-04-24 17:17:56 +0000794 if (isSimpleZero(E, CGF)) return CharUnits::Zero();
Chris Lattner1b726772010-12-02 07:07:26 +0000795
796 // If this is an initlist expr, sum up the size of sizes of the (present)
797 // elements. If this is something weird, assume the whole thing is non-zero.
798 const InitListExpr *ILE = dyn_cast<InitListExpr>(E);
799 if (ILE == 0 || !CGF.getTypes().isZeroInitializable(ILE->getType()))
Ken Dyck02c45332011-04-24 17:17:56 +0000800 return CGF.getContext().getTypeSizeInChars(E->getType());
Chris Lattner1b726772010-12-02 07:07:26 +0000801
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000802 // InitListExprs for structs have to be handled carefully. If there are
803 // reference members, we need to consider the size of the reference, not the
804 // referencee. InitListExprs for unions and arrays can't have references.
Chris Lattner8c00ad12010-12-02 22:52:04 +0000805 if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
806 if (!RT->isUnionType()) {
807 RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
Ken Dyck02c45332011-04-24 17:17:56 +0000808 CharUnits NumNonZeroBytes = CharUnits::Zero();
Chris Lattner8c00ad12010-12-02 22:52:04 +0000809
810 unsigned ILEElement = 0;
811 for (RecordDecl::field_iterator Field = SD->field_begin(),
812 FieldEnd = SD->field_end(); Field != FieldEnd; ++Field) {
813 // We're done once we hit the flexible array member or run out of
814 // InitListExpr elements.
815 if (Field->getType()->isIncompleteArrayType() ||
816 ILEElement == ILE->getNumInits())
817 break;
818 if (Field->isUnnamedBitfield())
819 continue;
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000820
Chris Lattner8c00ad12010-12-02 22:52:04 +0000821 const Expr *E = ILE->getInit(ILEElement++);
822
823 // Reference values are always non-null and have the width of a pointer.
824 if (Field->getType()->isReferenceType())
Ken Dyck02c45332011-04-24 17:17:56 +0000825 NumNonZeroBytes += CGF.getContext().toCharUnitsFromBits(
826 CGF.getContext().Target.getPointerWidth(0));
Chris Lattner8c00ad12010-12-02 22:52:04 +0000827 else
828 NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF);
829 }
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000830
Chris Lattner8c00ad12010-12-02 22:52:04 +0000831 return NumNonZeroBytes;
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000832 }
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000833 }
834
835
Ken Dyck02c45332011-04-24 17:17:56 +0000836 CharUnits NumNonZeroBytes = CharUnits::Zero();
Chris Lattner1b726772010-12-02 07:07:26 +0000837 for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
838 NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF);
839 return NumNonZeroBytes;
840}
841
842/// CheckAggExprForMemSetUse - If the initializer is large and has a lot of
843/// zeros in it, emit a memset and avoid storing the individual zeros.
844///
845static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,
846 CodeGenFunction &CGF) {
847 // If the slot is already known to be zeroed, nothing to do. Don't mess with
848 // volatile stores.
849 if (Slot.isZeroed() || Slot.isVolatile() || Slot.getAddr() == 0) return;
Argyrios Kyrtzidis657baf12011-04-28 22:57:55 +0000850
851 // C++ objects with a user-declared constructor don't need zero'ing.
852 if (CGF.getContext().getLangOptions().CPlusPlus)
853 if (const RecordType *RT = CGF.getContext()
854 .getBaseElementType(E->getType())->getAs<RecordType>()) {
855 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
856 if (RD->hasUserDeclaredConstructor())
857 return;
858 }
859
Chris Lattner1b726772010-12-02 07:07:26 +0000860 // If the type is 16-bytes or smaller, prefer individual stores over memset.
Ken Dyck5ff1a352011-04-24 17:25:32 +0000861 std::pair<CharUnits, CharUnits> TypeInfo =
862 CGF.getContext().getTypeInfoInChars(E->getType());
863 if (TypeInfo.first <= CharUnits::fromQuantity(16))
Chris Lattner1b726772010-12-02 07:07:26 +0000864 return;
865
866 // Check to see if over 3/4 of the initializer are known to be zero. If so,
867 // we prefer to emit memset + individual stores for the rest.
Ken Dyck5ff1a352011-04-24 17:25:32 +0000868 CharUnits NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF);
869 if (NumNonZeroBytes*4 > TypeInfo.first)
Chris Lattner1b726772010-12-02 07:07:26 +0000870 return;
871
872 // Okay, it seems like a good idea to use an initial memset, emit the call.
Ken Dyck5ff1a352011-04-24 17:25:32 +0000873 llvm::Constant *SizeVal = CGF.Builder.getInt64(TypeInfo.first.getQuantity());
874 CharUnits Align = TypeInfo.second;
Chris Lattner1b726772010-12-02 07:07:26 +0000875
876 llvm::Value *Loc = Slot.getAddr();
877 const llvm::Type *BP = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
878
879 Loc = CGF.Builder.CreateBitCast(Loc, BP);
Ken Dyck5ff1a352011-04-24 17:25:32 +0000880 CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal,
881 Align.getQuantity(), false);
Chris Lattner1b726772010-12-02 07:07:26 +0000882
883 // Tell the AggExprEmitter that the slot is known zero.
884 Slot.setZeroed();
885}
886
887
888
889
Mike Stumpe1129a92009-05-26 18:57:45 +0000890/// EmitAggExpr - Emit the computation of the specified expression of aggregate
891/// type. The result is computed into DestPtr. Note that if DestPtr is null,
892/// the value of the aggregate expression is not needed. If VolatileDest is
893/// true, DestPtr cannot be 0.
John McCall558d2ab2010-09-15 10:14:12 +0000894///
895/// \param IsInitializer - true if this evaluation is initializing an
896/// object whose lifetime is already being managed.
John McCall558d2ab2010-09-15 10:14:12 +0000897void CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot,
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000898 bool IgnoreResult) {
Chris Lattneree755f92007-08-21 04:59:27 +0000899 assert(E && hasAggregateLLVMType(E->getType()) &&
900 "Invalid aggregate expression to emit");
Chris Lattner1b726772010-12-02 07:07:26 +0000901 assert((Slot.getAddr() != 0 || Slot.isIgnored()) &&
902 "slot has bits but no address");
Mike Stump1eb44332009-09-09 15:08:12 +0000903
Chris Lattner1b726772010-12-02 07:07:26 +0000904 // Optimize the slot if possible.
905 CheckAggExprForMemSetUse(Slot, E, *this);
906
907 AggExprEmitter(*this, Slot, IgnoreResult).Visit(const_cast<Expr*>(E));
Chris Lattneree755f92007-08-21 04:59:27 +0000908}
Daniel Dunbar7482d122008-09-09 20:49:46 +0000909
Daniel Dunbar18aba0d2010-02-05 19:38:31 +0000910LValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) {
911 assert(hasAggregateLLVMType(E->getType()) && "Invalid argument!");
Daniel Dunbar195337d2010-02-09 02:48:28 +0000912 llvm::Value *Temp = CreateMemTemp(E->getType());
Daniel Dunbar79c39282010-08-21 03:15:20 +0000913 LValue LV = MakeAddrLValue(Temp, E->getType());
John McCallf85e1932011-06-15 23:02:42 +0000914 EmitAggExpr(E, AggValueSlot::forLValue(LV, false));
Daniel Dunbar79c39282010-08-21 03:15:20 +0000915 return LV;
Daniel Dunbar18aba0d2010-02-05 19:38:31 +0000916}
917
Daniel Dunbar7482d122008-09-09 20:49:46 +0000918void CodeGenFunction::EmitAggregateCopy(llvm::Value *DestPtr,
Mike Stump27fe2e62009-05-23 22:29:41 +0000919 llvm::Value *SrcPtr, QualType Ty,
920 bool isVolatile) {
Daniel Dunbar7482d122008-09-09 20:49:46 +0000921 assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
Mike Stump1eb44332009-09-09 15:08:12 +0000922
Anders Carlsson0d7c5832010-05-03 01:20:20 +0000923 if (getContext().getLangOptions().CPlusPlus) {
924 if (const RecordType *RT = Ty->getAs<RecordType>()) {
Douglas Gregore9979482010-05-20 15:39:01 +0000925 CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
926 assert((Record->hasTrivialCopyConstructor() ||
Fariborz Jahanian1d49f212010-05-20 16:46:55 +0000927 Record->hasTrivialCopyAssignment()) &&
Douglas Gregore9979482010-05-20 15:39:01 +0000928 "Trying to aggregate-copy a type without a trivial copy "
929 "constructor or assignment operator");
Douglas Gregor419aa962010-05-20 15:48:29 +0000930 // Ignore empty classes in C++.
Douglas Gregore9979482010-05-20 15:39:01 +0000931 if (Record->isEmpty())
Anders Carlsson0d7c5832010-05-03 01:20:20 +0000932 return;
933 }
934 }
935
Chris Lattner83c96292009-02-28 18:31:01 +0000936 // Aggregate assignment turns into llvm.memcpy. This is almost valid per
Chris Lattnerca4fc2c2009-02-28 18:18:58 +0000937 // C99 6.5.16.1p3, which states "If the value being stored in an object is
938 // read from another object that overlaps in anyway the storage of the first
939 // object, then the overlap shall be exact and the two objects shall have
940 // qualified or unqualified versions of a compatible type."
941 //
Chris Lattner83c96292009-02-28 18:31:01 +0000942 // memcpy is not defined if the source and destination pointers are exactly
Chris Lattnerca4fc2c2009-02-28 18:18:58 +0000943 // equal, but other compilers do this optimization, and almost every memcpy
944 // implementation handles this case safely. If there is a libc that does not
945 // safely handle this, we can add a target hook.
Mike Stump1eb44332009-09-09 15:08:12 +0000946
Daniel Dunbar7482d122008-09-09 20:49:46 +0000947 // Get size and alignment info for this aggregate.
Ken Dyck1a8c15a2011-04-24 17:37:26 +0000948 std::pair<CharUnits, CharUnits> TypeInfo =
949 getContext().getTypeInfoInChars(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +0000950
Daniel Dunbar7482d122008-09-09 20:49:46 +0000951 // FIXME: Handle variable sized types.
Mike Stump1eb44332009-09-09 15:08:12 +0000952
Mike Stumpfde64202009-05-23 04:13:59 +0000953 // FIXME: If we have a volatile struct, the optimizer can remove what might
954 // appear to be `extra' memory ops:
955 //
956 // volatile struct { int i; } a, b;
957 //
958 // int main() {
959 // a = b;
960 // a = b;
961 // }
962 //
Mon P Wang3ecd7852010-04-04 03:10:52 +0000963 // we need to use a different call here. We use isVolatile to indicate when
Mike Stump49d1cd52009-05-26 22:03:21 +0000964 // either the source or the destination is volatile.
Mon P Wang3ecd7852010-04-04 03:10:52 +0000965
966 const llvm::PointerType *DPT = cast<llvm::PointerType>(DestPtr->getType());
Chris Lattner098432c2010-07-08 00:07:45 +0000967 const llvm::Type *DBP =
John McCalld16c2cf2011-02-08 08:22:06 +0000968 llvm::Type::getInt8PtrTy(getLLVMContext(), DPT->getAddressSpace());
Chris Lattner098432c2010-07-08 00:07:45 +0000969 DestPtr = Builder.CreateBitCast(DestPtr, DBP, "tmp");
Mon P Wang3ecd7852010-04-04 03:10:52 +0000970
971 const llvm::PointerType *SPT = cast<llvm::PointerType>(SrcPtr->getType());
Chris Lattner098432c2010-07-08 00:07:45 +0000972 const llvm::Type *SBP =
John McCalld16c2cf2011-02-08 08:22:06 +0000973 llvm::Type::getInt8PtrTy(getLLVMContext(), SPT->getAddressSpace());
Chris Lattner098432c2010-07-08 00:07:45 +0000974 SrcPtr = Builder.CreateBitCast(SrcPtr, SBP, "tmp");
Mon P Wang3ecd7852010-04-04 03:10:52 +0000975
John McCallf85e1932011-06-15 23:02:42 +0000976 // Don't do any of the memmove_collectable tests if GC isn't set.
977 if (CGM.getLangOptions().getGCMode() == LangOptions::NonGC) {
978 // fall through
979 } else if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000980 RecordDecl *Record = RecordTy->getDecl();
981 if (Record->hasObjectMember()) {
Ken Dyck1a8c15a2011-04-24 17:37:26 +0000982 CharUnits size = TypeInfo.first;
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000983 const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
Ken Dyck1a8c15a2011-04-24 17:37:26 +0000984 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size.getQuantity());
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000985 CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
986 SizeVal);
987 return;
988 }
John McCallf85e1932011-06-15 23:02:42 +0000989 } else if (Ty->isArrayType()) {
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000990 QualType BaseType = getContext().getBaseElementType(Ty);
991 if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
992 if (RecordTy->getDecl()->hasObjectMember()) {
Ken Dyck1a8c15a2011-04-24 17:37:26 +0000993 CharUnits size = TypeInfo.first;
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000994 const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
Ken Dyck1a8c15a2011-04-24 17:37:26 +0000995 llvm::Value *SizeVal =
996 llvm::ConstantInt::get(SizeTy, size.getQuantity());
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000997 CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
998 SizeVal);
999 return;
1000 }
1001 }
1002 }
1003
Benjamin Kramer9f0c7cc2010-12-30 00:13:21 +00001004 Builder.CreateMemCpy(DestPtr, SrcPtr,
Ken Dyck1a8c15a2011-04-24 17:37:26 +00001005 llvm::ConstantInt::get(IntPtrTy,
1006 TypeInfo.first.getQuantity()),
1007 TypeInfo.second.getQuantity(), isVolatile);
Daniel Dunbar7482d122008-09-09 20:49:46 +00001008}