blob: d8da642a6b38c912c810f49021735aa5ecf6fa52 [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); }
Chris Lattnerf0a990c2009-04-21 23:00:09 +000094 void VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
Mike Stump1eb44332009-09-09 15:08:12 +000095 EmitAggLoadOfLValue(E);
Chris Lattnerf0a990c2009-04-21 23:00:09 +000096 }
Seo Sanghyeon9b73b392007-12-14 02:04:12 +000097 void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
98 EmitAggLoadOfLValue(E);
99 }
Chris Lattnerf0a990c2009-04-21 23:00:09 +0000100 void VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) {
Mike Stump1eb44332009-09-09 15:08:12 +0000101 EmitAggLoadOfLValue(E);
Chris Lattnerf0a990c2009-04-21 23:00:09 +0000102 }
103 void VisitPredefinedExpr(const PredefinedExpr *E) {
Mike Stump1eb44332009-09-09 15:08:12 +0000104 EmitAggLoadOfLValue(E);
Chris Lattnerf0a990c2009-04-21 23:00:09 +0000105 }
Mike Stump1eb44332009-09-09 15:08:12 +0000106
Chris Lattner9c033562007-08-21 04:25:47 +0000107 // Operators.
Anders Carlsson4d8673b2009-08-07 23:22:37 +0000108 void VisitCastExpr(CastExpr *E);
Anders Carlsson148fe672007-10-31 22:04:46 +0000109 void VisitCallExpr(const CallExpr *E);
Chris Lattnerb2d963f2007-08-31 22:54:14 +0000110 void VisitStmtExpr(const StmtExpr *E);
Chris Lattner9c033562007-08-21 04:25:47 +0000111 void VisitBinaryOperator(const BinaryOperator *BO);
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +0000112 void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO);
Chris Lattner03d6fb92007-08-21 04:43:17 +0000113 void VisitBinAssign(const BinaryOperator *E);
Eli Friedman07fa52a2008-05-20 07:56:31 +0000114 void VisitBinComma(const BinaryOperator *E);
Chris Lattner9c033562007-08-21 04:25:47 +0000115
Chris Lattner8fdf3282008-06-24 17:04:18 +0000116 void VisitObjCMessageExpr(ObjCMessageExpr *E);
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000117 void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
118 EmitAggLoadOfLValue(E);
119 }
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000120 void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
Mike Stump1eb44332009-09-09 15:08:12 +0000121
John McCall56ca35d2011-02-17 10:25:35 +0000122 void VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
Anders Carlssona294ca82009-07-08 18:33:14 +0000123 void VisitChooseExpr(const ChooseExpr *CE);
Devang Patel636c3d02007-10-26 17:44:44 +0000124 void VisitInitListExpr(InitListExpr *E);
Anders Carlsson30311fa2009-12-16 06:57:54 +0000125 void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
Chris Lattner04421082008-04-08 04:40:51 +0000126 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
127 Visit(DAE->getExpr());
128 }
Anders Carlssonb58d0172009-05-30 23:23:33 +0000129 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
Anders Carlsson31ccf372009-05-03 17:47:16 +0000130 void VisitCXXConstructExpr(const CXXConstructExpr *E);
John McCall4765fa02010-12-06 08:20:24 +0000131 void VisitExprWithCleanups(ExprWithCleanups *E);
Douglas Gregored8abf12010-07-08 06:14:04 +0000132 void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
Mike Stump2710c412009-11-18 00:40:12 +0000133 void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); }
Anders Carlsson7f6ad152009-05-19 04:48:36 +0000134
John McCalle996ffd2011-02-16 08:02:54 +0000135 void VisitOpaqueValueExpr(OpaqueValueExpr *E);
136
Eli Friedmanb1851242008-05-27 15:51:49 +0000137 void VisitVAArgExpr(VAArgExpr *E);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000138
Anders Carlsson78e83f82010-02-03 17:33:16 +0000139 void EmitInitializationToLValue(Expr *E, LValue Address, QualType T);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000140 void EmitNullInitializationToLValue(LValue Address, QualType T);
Chris Lattner9c033562007-08-21 04:25:47 +0000141 // case Expr::ChooseExprClass:
Mike Stump39406b12009-12-09 19:24:08 +0000142 void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
Chris Lattner9c033562007-08-21 04:25:47 +0000143};
144} // end anonymous namespace.
145
Chris Lattneree755f92007-08-21 04:59:27 +0000146//===----------------------------------------------------------------------===//
147// Utilities
148//===----------------------------------------------------------------------===//
Chris Lattner9c033562007-08-21 04:25:47 +0000149
Chris Lattner883f6a72007-08-11 00:04:45 +0000150/// EmitAggLoadOfLValue - Given an expression with aggregate type that
151/// represents a value lvalue, this method emits the address of the lvalue,
152/// then loads the result into DestPtr.
Chris Lattner9c033562007-08-21 04:25:47 +0000153void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
154 LValue LV = CGF.EmitLValue(E);
Mike Stump4ac20dd2009-05-23 20:28:01 +0000155 EmitFinalDestCopy(E, LV);
156}
157
John McCallfa037bd2010-05-22 22:13:32 +0000158/// \brief True if the given aggregate type requires special GC API calls.
159bool AggExprEmitter::TypeRequiresGCollection(QualType T) {
160 // Only record types have members that might require garbage collection.
161 const RecordType *RecordTy = T->getAs<RecordType>();
162 if (!RecordTy) return false;
163
164 // Don't mess with non-trivial C++ types.
165 RecordDecl *Record = RecordTy->getDecl();
166 if (isa<CXXRecordDecl>(Record) &&
167 (!cast<CXXRecordDecl>(Record)->hasTrivialCopyConstructor() ||
168 !cast<CXXRecordDecl>(Record)->hasTrivialDestructor()))
169 return false;
170
171 // Check whether the type has an object member.
172 return Record->hasObjectMember();
173}
174
175/// \brief Perform the final move to DestPtr if RequiresGCollection is set.
176///
177/// The idea is that you do something like this:
178/// RValue Result = EmitSomething(..., getReturnValueSlot());
179/// EmitGCMove(E, Result);
180/// If GC doesn't interfere, this will cause the result to be emitted
181/// directly into the return value slot. If GC does interfere, a final
182/// move will be performed.
183void AggExprEmitter::EmitGCMove(const Expr *E, RValue Src) {
John McCalld1a5f132010-09-16 03:13:23 +0000184 if (Dest.requiresGCollection()) {
Ken Dyck479b61c2011-04-24 17:08:00 +0000185 CharUnits size = CGF.getContext().getTypeSizeInChars(E->getType());
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000186 const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
Ken Dyck479b61c2011-04-24 17:08:00 +0000187 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size.getQuantity());
John McCall558d2ab2010-09-15 10:14:12 +0000188 CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF, Dest.getAddr(),
John McCallfa037bd2010-05-22 22:13:32 +0000189 Src.getAggregateAddr(),
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000190 SizeVal);
191 }
John McCallfa037bd2010-05-22 22:13:32 +0000192}
193
Mike Stump4ac20dd2009-05-23 20:28:01 +0000194/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
Mike Stump49d1cd52009-05-26 22:03:21 +0000195void AggExprEmitter::EmitFinalDestCopy(const Expr *E, RValue Src, bool Ignore) {
Mike Stump4ac20dd2009-05-23 20:28:01 +0000196 assert(Src.isAggregate() && "value must be aggregate value!");
197
John McCall558d2ab2010-09-15 10:14:12 +0000198 // If Dest is ignored, then we're evaluating an aggregate expression
John McCalla8f28da2010-08-25 02:50:31 +0000199 // in a context (like an expression statement) that doesn't care
200 // about the result. C says that an lvalue-to-rvalue conversion is
201 // performed in these cases; C++ says that it is not. In either
202 // case, we don't actually need to do anything unless the value is
203 // volatile.
John McCall558d2ab2010-09-15 10:14:12 +0000204 if (Dest.isIgnored()) {
John McCalla8f28da2010-08-25 02:50:31 +0000205 if (!Src.isVolatileQualified() ||
206 CGF.CGM.getLangOptions().CPlusPlus ||
207 (IgnoreResult && Ignore))
Mike Stump9ccb1032009-05-23 22:01:27 +0000208 return;
Fariborz Jahanian8a970052010-10-22 22:05:03 +0000209
Mike Stump49d1cd52009-05-26 22:03:21 +0000210 // If the source is volatile, we must read from it; to do that, we need
211 // some place to put it.
John McCall558d2ab2010-09-15 10:14:12 +0000212 Dest = CGF.CreateAggTemp(E->getType(), "agg.tmp");
Mike Stump9ccb1032009-05-23 22:01:27 +0000213 }
Chris Lattner883f6a72007-08-11 00:04:45 +0000214
John McCalld1a5f132010-09-16 03:13:23 +0000215 if (Dest.requiresGCollection()) {
Ken Dyck479b61c2011-04-24 17:08:00 +0000216 CharUnits size = CGF.getContext().getTypeSizeInChars(E->getType());
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000217 const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
Ken Dyck479b61c2011-04-24 17:08:00 +0000218 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size.getQuantity());
Fariborz Jahanian08c32132009-08-31 19:33:16 +0000219 CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF,
John McCall558d2ab2010-09-15 10:14:12 +0000220 Dest.getAddr(),
221 Src.getAggregateAddr(),
222 SizeVal);
Fariborz Jahanian08c32132009-08-31 19:33:16 +0000223 return;
224 }
Mike Stump4ac20dd2009-05-23 20:28:01 +0000225 // If the result of the assignment is used, copy the LHS there also.
226 // FIXME: Pass VolatileDest as well. I think we also need to merge volatile
227 // from the source as well, as we can't eliminate it if either operand
228 // is volatile, unless copy has volatile for both source and destination..
John McCall558d2ab2010-09-15 10:14:12 +0000229 CGF.EmitAggregateCopy(Dest.getAddr(), Src.getAggregateAddr(), E->getType(),
230 Dest.isVolatile()|Src.isVolatileQualified());
Mike Stump4ac20dd2009-05-23 20:28:01 +0000231}
232
233/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
Mike Stump49d1cd52009-05-26 22:03:21 +0000234void AggExprEmitter::EmitFinalDestCopy(const Expr *E, LValue Src, bool Ignore) {
Mike Stump4ac20dd2009-05-23 20:28:01 +0000235 assert(Src.isSimple() && "Can't have aggregate bitfield, vector, etc");
236
237 EmitFinalDestCopy(E, RValue::getAggregate(Src.getAddress(),
Mike Stump49d1cd52009-05-26 22:03:21 +0000238 Src.isVolatileQualified()),
239 Ignore);
Chris Lattner883f6a72007-08-11 00:04:45 +0000240}
241
Chris Lattneree755f92007-08-21 04:59:27 +0000242//===----------------------------------------------------------------------===//
243// Visitor Methods
244//===----------------------------------------------------------------------===//
245
John McCalle996ffd2011-02-16 08:02:54 +0000246void AggExprEmitter::VisitOpaqueValueExpr(OpaqueValueExpr *e) {
John McCall56ca35d2011-02-17 10:25:35 +0000247 EmitFinalDestCopy(e, CGF.getOpaqueLValueMapping(e));
John McCalle996ffd2011-02-16 08:02:54 +0000248}
249
Anders Carlsson4d8673b2009-08-07 23:22:37 +0000250void AggExprEmitter::VisitCastExpr(CastExpr *E) {
Anders Carlsson30168422009-09-29 01:23:39 +0000251 switch (E->getCastKind()) {
Anders Carlsson575b3742011-04-11 02:03:26 +0000252 case CK_Dynamic: {
Douglas Gregor69cfeb12010-05-14 21:31:02 +0000253 assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?");
254 LValue LV = CGF.EmitCheckedLValue(E->getSubExpr());
255 // FIXME: Do we also need to handle property references here?
256 if (LV.isSimple())
257 CGF.EmitDynamicCast(LV.getAddress(), cast<CXXDynamicCastExpr>(E));
258 else
259 CGF.CGM.ErrorUnsupported(E, "non-simple lvalue dynamic_cast");
260
John McCall558d2ab2010-09-15 10:14:12 +0000261 if (!Dest.isIgnored())
262 CGF.CGM.ErrorUnsupported(E, "lvalue dynamic_cast with a destination");
Douglas Gregor69cfeb12010-05-14 21:31:02 +0000263 break;
264 }
265
John McCall2de56d12010-08-25 11:45:40 +0000266 case CK_ToUnion: {
John McCall65912712011-04-12 22:02:02 +0000267 if (Dest.isIgnored()) break;
268
Anders Carlsson4d8673b2009-08-07 23:22:37 +0000269 // GCC union extension
Daniel Dunbar79c39282010-08-21 03:15:20 +0000270 QualType Ty = E->getSubExpr()->getType();
271 QualType PtrTy = CGF.getContext().getPointerType(Ty);
John McCall558d2ab2010-09-15 10:14:12 +0000272 llvm::Value *CastPtr = Builder.CreateBitCast(Dest.getAddr(),
Eli Friedman34ebf4d2009-06-03 20:45:06 +0000273 CGF.ConvertType(PtrTy));
Daniel Dunbar79c39282010-08-21 03:15:20 +0000274 EmitInitializationToLValue(E->getSubExpr(), CGF.MakeAddrLValue(CastPtr, Ty),
275 Ty);
Anders Carlsson30168422009-09-29 01:23:39 +0000276 break;
Nuno Lopes7e916272009-01-15 20:14:33 +0000277 }
Mike Stump1eb44332009-09-09 15:08:12 +0000278
John McCall2de56d12010-08-25 11:45:40 +0000279 case CK_DerivedToBase:
280 case CK_BaseToDerived:
281 case CK_UncheckedDerivedToBase: {
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000282 assert(0 && "cannot perform hierarchy conversion in EmitAggExpr: "
283 "should have been unpacked before we got here");
284 break;
285 }
286
John McCallf6a16482010-12-04 03:47:34 +0000287 case CK_GetObjCProperty: {
288 LValue LV = CGF.EmitLValue(E->getSubExpr());
289 assert(LV.isPropertyRef());
290 RValue RV = CGF.EmitLoadOfPropertyRefLValue(LV, getReturnValueSlot());
291 EmitGCMove(E, RV);
292 break;
293 }
294
295 case CK_LValueToRValue: // hope for downstream optimization
John McCall2de56d12010-08-25 11:45:40 +0000296 case CK_NoOp:
297 case CK_UserDefinedConversion:
298 case CK_ConstructorConversion:
Anders Carlsson30168422009-09-29 01:23:39 +0000299 assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(),
300 E->getType()) &&
301 "Implicit cast types must be compatible");
302 Visit(E->getSubExpr());
303 break;
John McCall0ae287a2010-12-01 04:43:34 +0000304
John McCall2de56d12010-08-25 11:45:40 +0000305 case CK_LValueBitCast:
John McCall0ae287a2010-12-01 04:43:34 +0000306 llvm_unreachable("should not be emitting lvalue bitcast as rvalue");
Douglas Gregore39a3892010-07-13 23:17:26 +0000307 break;
John McCall1de4d4e2011-04-07 08:22:57 +0000308
John McCall0ae287a2010-12-01 04:43:34 +0000309 case CK_Dependent:
310 case CK_BitCast:
311 case CK_ArrayToPointerDecay:
312 case CK_FunctionToPointerDecay:
313 case CK_NullToPointer:
314 case CK_NullToMemberPointer:
315 case CK_BaseToDerivedMemberPointer:
316 case CK_DerivedToBaseMemberPointer:
317 case CK_MemberPointerToBoolean:
318 case CK_IntegralToPointer:
319 case CK_PointerToIntegral:
320 case CK_PointerToBoolean:
321 case CK_ToVoid:
322 case CK_VectorSplat:
323 case CK_IntegralCast:
324 case CK_IntegralToBoolean:
325 case CK_IntegralToFloating:
326 case CK_FloatingToIntegral:
327 case CK_FloatingToBoolean:
328 case CK_FloatingCast:
329 case CK_AnyPointerToObjCPointerCast:
330 case CK_AnyPointerToBlockPointerCast:
331 case CK_ObjCObjectLValueCast:
332 case CK_FloatingRealToComplex:
333 case CK_FloatingComplexToReal:
334 case CK_FloatingComplexToBoolean:
335 case CK_FloatingComplexCast:
336 case CK_FloatingComplexToIntegralComplex:
337 case CK_IntegralRealToComplex:
338 case CK_IntegralComplexToReal:
339 case CK_IntegralComplexToBoolean:
340 case CK_IntegralComplexCast:
341 case CK_IntegralComplexToFloatingComplex:
342 llvm_unreachable("cast kind invalid for aggregate types");
Anders Carlsson30168422009-09-29 01:23:39 +0000343 }
Anders Carlssone4707ff2008-01-14 06:28:57 +0000344}
345
Chris Lattner96196622008-07-26 22:37:01 +0000346void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
Anders Carlssone70e8f72009-05-27 16:45:02 +0000347 if (E->getCallReturnType()->isReferenceType()) {
348 EmitAggLoadOfLValue(E);
349 return;
350 }
Mike Stump1eb44332009-09-09 15:08:12 +0000351
John McCallfa037bd2010-05-22 22:13:32 +0000352 RValue RV = CGF.EmitCallExpr(E, getReturnValueSlot());
353 EmitGCMove(E, RV);
Anders Carlsson148fe672007-10-31 22:04:46 +0000354}
Chris Lattner96196622008-07-26 22:37:01 +0000355
356void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
John McCallfa037bd2010-05-22 22:13:32 +0000357 RValue RV = CGF.EmitObjCMessageExpr(E, getReturnValueSlot());
358 EmitGCMove(E, RV);
Chris Lattner8fdf3282008-06-24 17:04:18 +0000359}
Anders Carlsson148fe672007-10-31 22:04:46 +0000360
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000361void AggExprEmitter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
John McCallf6a16482010-12-04 03:47:34 +0000362 llvm_unreachable("direct property access not surrounded by "
363 "lvalue-to-rvalue cast");
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000364}
365
Chris Lattner96196622008-07-26 22:37:01 +0000366void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
John McCall2a416372010-12-05 02:00:02 +0000367 CGF.EmitIgnoredExpr(E->getLHS());
John McCall558d2ab2010-09-15 10:14:12 +0000368 Visit(E->getRHS());
Eli Friedman07fa52a2008-05-20 07:56:31 +0000369}
370
Chris Lattnerb2d963f2007-08-31 22:54:14 +0000371void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
John McCall150b4622011-01-26 04:00:11 +0000372 CodeGenFunction::StmtExprEvaluation eval(CGF);
John McCall558d2ab2010-09-15 10:14:12 +0000373 CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest);
Chris Lattnerb2d963f2007-08-31 22:54:14 +0000374}
375
Chris Lattner9c033562007-08-21 04:25:47 +0000376void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
John McCall2de56d12010-08-25 11:45:40 +0000377 if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI)
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +0000378 VisitPointerToDataMemberBinaryOperator(E);
379 else
380 CGF.ErrorUnsupported(E, "aggregate binary expression");
381}
382
383void AggExprEmitter::VisitPointerToDataMemberBinaryOperator(
384 const BinaryOperator *E) {
385 LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E);
386 EmitFinalDestCopy(E, LV);
Chris Lattneree755f92007-08-21 04:59:27 +0000387}
388
Chris Lattner03d6fb92007-08-21 04:43:17 +0000389void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
Eli Friedmanff6e2b72008-02-11 01:09:17 +0000390 // For an assignment to work, the value on the right has
391 // to be compatible with the value on the left.
Eli Friedman2dce5f82009-05-28 23:04:00 +0000392 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
393 E->getRHS()->getType())
Eli Friedmanff6e2b72008-02-11 01:09:17 +0000394 && "Invalid assignment");
John McCallcd940a12010-12-06 06:10:02 +0000395
Fariborz Jahanian2c7168c2011-04-29 21:53:21 +0000396 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->getLHS()))
Fariborz Jahanian73a6f8e2011-04-29 22:11:28 +0000397 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl()))
Fariborz Jahanian2c7168c2011-04-29 21:53:21 +0000398 if (VD->hasAttr<BlocksAttr>() &&
399 E->getRHS()->HasSideEffects(CGF.getContext())) {
400 // When __block variable on LHS, the RHS must be evaluated first
401 // as it may change the 'forwarding' field via call to Block_copy.
402 LValue RHS = CGF.EmitLValue(E->getRHS());
403 LValue LHS = CGF.EmitLValue(E->getLHS());
404 bool GCollection = false;
405 if (CGF.getContext().getLangOptions().getGCMode())
406 GCollection = TypeRequiresGCollection(E->getLHS()->getType());
Fariborz Jahanian2c7168c2011-04-29 21:53:21 +0000407 Dest = AggValueSlot::forLValue(LHS, true, GCollection);
408 EmitFinalDestCopy(E, RHS, true);
409 return;
410 }
Fariborz Jahanian2c7168c2011-04-29 21:53:21 +0000411
Chris Lattner9c033562007-08-21 04:25:47 +0000412 LValue LHS = CGF.EmitLValue(E->getLHS());
Chris Lattner883f6a72007-08-11 00:04:45 +0000413
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000414 // We have to special case property setters, otherwise we must have
415 // a simple lvalue (no aggregates inside vectors, bitfields).
416 if (LHS.isPropertyRef()) {
Fariborz Jahanian68af13f2011-03-30 16:11:20 +0000417 const ObjCPropertyRefExpr *RE = LHS.getPropertyRefExpr();
418 QualType ArgType = RE->getSetterArgType();
419 RValue Src;
420 if (ArgType->isReferenceType())
421 Src = CGF.EmitReferenceBindingToExpr(E->getRHS(), 0);
422 else {
423 AggValueSlot Slot = EnsureSlot(E->getRHS()->getType());
424 CGF.EmitAggExpr(E->getRHS(), Slot);
425 Src = Slot.asRValue();
426 }
427 CGF.EmitStoreThroughPropertyRefLValue(Src, LHS);
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000428 } else {
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000429 bool GCollection = false;
John McCallfa037bd2010-05-22 22:13:32 +0000430 if (CGF.getContext().getLangOptions().getGCMode())
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000431 GCollection = TypeRequiresGCollection(E->getLHS()->getType());
John McCallfa037bd2010-05-22 22:13:32 +0000432
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000433 // Codegen the RHS so that it stores directly into the LHS.
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000434 AggValueSlot LHSSlot = AggValueSlot::forLValue(LHS, true,
435 GCollection);
436 CGF.EmitAggExpr(E->getRHS(), LHSSlot, false);
Mike Stump49d1cd52009-05-26 22:03:21 +0000437 EmitFinalDestCopy(E, LHS, true);
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000438 }
Chris Lattner883f6a72007-08-11 00:04:45 +0000439}
440
John McCall56ca35d2011-02-17 10:25:35 +0000441void AggExprEmitter::
442VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
Daniel Dunbar9615ecb2008-11-13 01:38:36 +0000443 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
444 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
445 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
Mike Stump1eb44332009-09-09 15:08:12 +0000446
John McCall56ca35d2011-02-17 10:25:35 +0000447 // Bind the common expression if necessary.
448 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
449
John McCall150b4622011-01-26 04:00:11 +0000450 CodeGenFunction::ConditionalEvaluation eval(CGF);
Eli Friedman8e274bd2009-12-25 06:17:05 +0000451 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000452
John McCall74fb0ed2010-11-17 00:07:33 +0000453 // Save whether the destination's lifetime is externally managed.
454 bool DestLifetimeManaged = Dest.isLifetimeExternallyManaged();
Chris Lattner883f6a72007-08-11 00:04:45 +0000455
John McCall150b4622011-01-26 04:00:11 +0000456 eval.begin(CGF);
457 CGF.EmitBlock(LHSBlock);
John McCall56ca35d2011-02-17 10:25:35 +0000458 Visit(E->getTrueExpr());
John McCall150b4622011-01-26 04:00:11 +0000459 eval.end(CGF);
Mike Stump1eb44332009-09-09 15:08:12 +0000460
John McCall150b4622011-01-26 04:00:11 +0000461 assert(CGF.HaveInsertPoint() && "expression evaluation ended with no IP!");
462 CGF.Builder.CreateBr(ContBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000463
John McCall74fb0ed2010-11-17 00:07:33 +0000464 // If the result of an agg expression is unused, then the emission
465 // of the LHS might need to create a destination slot. That's fine
466 // with us, and we can safely emit the RHS into the same slot, but
467 // we shouldn't claim that its lifetime is externally managed.
468 Dest.setLifetimeExternallyManaged(DestLifetimeManaged);
469
John McCall150b4622011-01-26 04:00:11 +0000470 eval.begin(CGF);
471 CGF.EmitBlock(RHSBlock);
John McCall56ca35d2011-02-17 10:25:35 +0000472 Visit(E->getFalseExpr());
John McCall150b4622011-01-26 04:00:11 +0000473 eval.end(CGF);
Mike Stump1eb44332009-09-09 15:08:12 +0000474
Chris Lattner9c033562007-08-21 04:25:47 +0000475 CGF.EmitBlock(ContBlock);
Chris Lattner883f6a72007-08-11 00:04:45 +0000476}
Chris Lattneree755f92007-08-21 04:59:27 +0000477
Anders Carlssona294ca82009-07-08 18:33:14 +0000478void AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) {
479 Visit(CE->getChosenSubExpr(CGF.getContext()));
480}
481
Eli Friedmanb1851242008-05-27 15:51:49 +0000482void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
Daniel Dunbar07855702009-02-11 22:25:55 +0000483 llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr());
Anders Carlssonddf7cac2008-11-04 05:30:00 +0000484 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType());
485
Sebastian Redl0262f022009-01-09 21:09:38 +0000486 if (!ArgPtr) {
Anders Carlssonddf7cac2008-11-04 05:30:00 +0000487 CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
Sebastian Redl0262f022009-01-09 21:09:38 +0000488 return;
489 }
490
Daniel Dunbar79c39282010-08-21 03:15:20 +0000491 EmitFinalDestCopy(VE, CGF.MakeAddrLValue(ArgPtr, VE->getType()));
Eli Friedmanb1851242008-05-27 15:51:49 +0000492}
493
Anders Carlssonb58d0172009-05-30 23:23:33 +0000494void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000495 // Ensure that we have a slot, but if we already do, remember
496 // whether its lifetime was externally managed.
497 bool WasManaged = Dest.isLifetimeExternallyManaged();
498 Dest = EnsureSlot(E->getType());
499 Dest.setLifetimeExternallyManaged();
Mike Stump1eb44332009-09-09 15:08:12 +0000500
John McCall558d2ab2010-09-15 10:14:12 +0000501 Visit(E->getSubExpr());
Anders Carlssonb58d0172009-05-30 23:23:33 +0000502
John McCall558d2ab2010-09-15 10:14:12 +0000503 // Set up the temporary's destructor if its lifetime wasn't already
504 // being managed.
505 if (!WasManaged)
506 CGF.EmitCXXTemporary(E->getTemporary(), Dest.getAddr());
Anders Carlssonb58d0172009-05-30 23:23:33 +0000507}
508
Anders Carlssonb14095a2009-04-17 00:06:03 +0000509void
Anders Carlsson31ccf372009-05-03 17:47:16 +0000510AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000511 AggValueSlot Slot = EnsureSlot(E->getType());
512 CGF.EmitCXXConstructExpr(E, Slot);
Anders Carlsson7f6ad152009-05-19 04:48:36 +0000513}
514
John McCall4765fa02010-12-06 08:20:24 +0000515void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
516 CGF.EmitExprWithCleanups(E, Dest);
Anders Carlssonb14095a2009-04-17 00:06:03 +0000517}
518
Douglas Gregored8abf12010-07-08 06:14:04 +0000519void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000520 QualType T = E->getType();
521 AggValueSlot Slot = EnsureSlot(T);
522 EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T), T);
Anders Carlsson30311fa2009-12-16 06:57:54 +0000523}
524
525void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000526 QualType T = E->getType();
527 AggValueSlot Slot = EnsureSlot(T);
528 EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T), T);
Nuno Lopes329763b2009-10-18 15:18:11 +0000529}
530
Chris Lattner1b726772010-12-02 07:07:26 +0000531/// isSimpleZero - If emitting this value will obviously just cause a store of
532/// zero to memory, return true. This can return false if uncertain, so it just
533/// handles simple cases.
534static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {
Peter Collingbournef111d932011-04-15 00:35:48 +0000535 E = E->IgnoreParens();
536
Chris Lattner1b726772010-12-02 07:07:26 +0000537 // 0
538 if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
539 return IL->getValue() == 0;
540 // +0.0
541 if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E))
542 return FL->getValue().isPosZero();
543 // int()
544 if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) &&
545 CGF.getTypes().isZeroInitializable(E->getType()))
546 return true;
547 // (int*)0 - Null pointer expressions.
548 if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
549 return ICE->getCastKind() == CK_NullToPointer;
550 // '\0'
551 if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E))
552 return CL->getValue() == 0;
553
554 // Otherwise, hard case: conservatively return false.
555 return false;
556}
557
558
Anders Carlsson78e83f82010-02-03 17:33:16 +0000559void
560AggExprEmitter::EmitInitializationToLValue(Expr* E, LValue LV, QualType T) {
Mike Stump7f79f9b2009-05-29 15:46:01 +0000561 // FIXME: Ignore result?
Chris Lattnerf81557c2008-04-04 18:42:16 +0000562 // FIXME: Are initializers affected by volatile?
Chris Lattner1b726772010-12-02 07:07:26 +0000563 if (Dest.isZeroed() && isSimpleZero(E, CGF)) {
564 // Storing "i32 0" to a zero'd memory location is a noop.
565 } else if (isa<ImplicitValueInitExpr>(E)) {
Anders Carlsson78e83f82010-02-03 17:33:16 +0000566 EmitNullInitializationToLValue(LV, T);
Anders Carlssone78ccb42010-02-03 19:13:55 +0000567 } else if (T->isReferenceType()) {
Anders Carlsson32f36ba2010-06-26 16:35:32 +0000568 RValue RV = CGF.EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
Anders Carlssone78ccb42010-02-03 19:13:55 +0000569 CGF.EmitStoreThroughLValue(RV, LV, T);
Anders Carlsson78e83f82010-02-03 17:33:16 +0000570 } else if (T->isAnyComplexType()) {
Douglas Gregor3498bdb2009-01-29 17:44:32 +0000571 CGF.EmitComplexExprIntoAddr(E, LV.getAddress(), false);
Anders Carlsson78e83f82010-02-03 17:33:16 +0000572 } else if (CGF.hasAggregateLLVMType(T)) {
Chris Lattner1b726772010-12-02 07:07:26 +0000573 CGF.EmitAggExpr(E, AggValueSlot::forAddr(LV.getAddress(), false, true,
574 false, Dest.isZeroed()));
Eli Friedmanc8ba9612008-05-12 15:06:05 +0000575 } else {
John McCall2a416372010-12-05 02:00:02 +0000576 CGF.EmitStoreThroughLValue(RValue::get(CGF.EmitScalarExpr(E)), LV, T);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000577 }
Chris Lattnerf81557c2008-04-04 18:42:16 +0000578}
579
580void AggExprEmitter::EmitNullInitializationToLValue(LValue LV, QualType T) {
Chris Lattner1b726772010-12-02 07:07:26 +0000581 // If the destination slot is already zeroed out before the aggregate is
582 // copied into it, we don't have to emit any zeros here.
583 if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(T))
584 return;
585
Chris Lattnerf81557c2008-04-04 18:42:16 +0000586 if (!CGF.hasAggregateLLVMType(T)) {
587 // For non-aggregates, we can store zero
Owen Andersonc9c88b42009-07-31 20:28:54 +0000588 llvm::Value *Null = llvm::Constant::getNullValue(CGF.ConvertType(T));
Daniel Dunbar82397132008-08-06 05:32:55 +0000589 CGF.EmitStoreThroughLValue(RValue::get(Null), LV, T);
Lauro Ramos Venancio145cd892008-02-19 19:27:31 +0000590 } else {
Chris Lattnerf81557c2008-04-04 18:42:16 +0000591 // There's a potential optimization opportunity in combining
592 // memsets; that would be easy for arrays, but relatively
593 // difficult for structures with the current code.
Anders Carlsson1884eb02010-05-22 17:35:42 +0000594 CGF.EmitNullInitialization(LV.getAddress(), T);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000595 }
596}
597
Chris Lattnerf81557c2008-04-04 18:42:16 +0000598void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
Eli Friedmana385b3c2008-12-02 01:17:45 +0000599#if 0
Eli Friedman13a5be12009-12-04 01:30:56 +0000600 // FIXME: Assess perf here? Figure out what cases are worth optimizing here
601 // (Length of globals? Chunks of zeroed-out space?).
Eli Friedmana385b3c2008-12-02 01:17:45 +0000602 //
Mike Stumpf5408fe2009-05-16 07:57:57 +0000603 // If we can, prefer a copy from a global; this is a lot less code for long
604 // globals, and it's easier for the current optimizers to analyze.
Eli Friedman13a5be12009-12-04 01:30:56 +0000605 if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) {
Eli Friedman994ffef2008-11-30 02:11:09 +0000606 llvm::GlobalVariable* GV =
Eli Friedman13a5be12009-12-04 01:30:56 +0000607 new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true,
608 llvm::GlobalValue::InternalLinkage, C, "");
Daniel Dunbar79c39282010-08-21 03:15:20 +0000609 EmitFinalDestCopy(E, CGF.MakeAddrLValue(GV, E->getType()));
Eli Friedman994ffef2008-11-30 02:11:09 +0000610 return;
611 }
Eli Friedmana385b3c2008-12-02 01:17:45 +0000612#endif
Chris Lattnerd0db03a2010-09-06 00:11:41 +0000613 if (E->hadArrayRangeDesignator())
Douglas Gregora9c87802009-01-29 19:42:23 +0000614 CGF.ErrorUnsupported(E, "GNU array range designator extension");
Douglas Gregora9c87802009-01-29 19:42:23 +0000615
John McCall558d2ab2010-09-15 10:14:12 +0000616 llvm::Value *DestPtr = Dest.getAddr();
617
Chris Lattnerf81557c2008-04-04 18:42:16 +0000618 // Handle initialization of an array.
619 if (E->getType()->isArrayType()) {
620 const llvm::PointerType *APType =
621 cast<llvm::PointerType>(DestPtr->getType());
622 const llvm::ArrayType *AType =
623 cast<llvm::ArrayType>(APType->getElementType());
Mike Stump1eb44332009-09-09 15:08:12 +0000624
Chris Lattnerf81557c2008-04-04 18:42:16 +0000625 uint64_t NumInitElements = E->getNumInits();
Eli Friedman922696f2008-05-19 17:51:16 +0000626
Chris Lattner96196622008-07-26 22:37:01 +0000627 if (E->getNumInits() > 0) {
628 QualType T1 = E->getType();
629 QualType T2 = E->getInit(0)->getType();
Eli Friedman2dce5f82009-05-28 23:04:00 +0000630 if (CGF.getContext().hasSameUnqualifiedType(T1, T2)) {
Chris Lattner96196622008-07-26 22:37:01 +0000631 EmitAggLoadOfLValue(E->getInit(0));
632 return;
633 }
Eli Friedman922696f2008-05-19 17:51:16 +0000634 }
635
Chris Lattnerf81557c2008-04-04 18:42:16 +0000636 uint64_t NumArrayElements = AType->getNumElements();
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000637 QualType ElementType = CGF.getContext().getCanonicalType(E->getType());
Douglas Gregor4c678342009-01-28 21:54:33 +0000638 ElementType = CGF.getContext().getAsArrayType(ElementType)->getElementType();
Mike Stump1eb44332009-09-09 15:08:12 +0000639
Argyrios Kyrtzidis3b4d4902011-04-28 18:53:58 +0000640 bool hasNonTrivialCXXConstructor = false;
641 if (CGF.getContext().getLangOptions().CPlusPlus)
Argyrios Kyrtzidis49621532011-04-28 20:07:15 +0000642 if (const RecordType *RT = CGF.getContext()
643 .getBaseElementType(ElementType)->getAs<RecordType>()) {
Argyrios Kyrtzidis3b4d4902011-04-28 18:53:58 +0000644 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
Sean Hunt023df372011-05-09 18:22:59 +0000645 hasNonTrivialCXXConstructor = !RD->hasTrivialDefaultConstructor();
Argyrios Kyrtzidis3b4d4902011-04-28 18:53:58 +0000646 }
647
John McCall0953e762009-09-24 19:53:00 +0000648 // FIXME: were we intentionally ignoring address spaces and GC attributes?
Eli Friedman1e692ac2008-06-13 23:01:12 +0000649
Chris Lattnerf81557c2008-04-04 18:42:16 +0000650 for (uint64_t i = 0; i != NumArrayElements; ++i) {
Chris Lattner1b726772010-12-02 07:07:26 +0000651 // If we're done emitting initializers and the destination is known-zeroed
652 // then we're done.
653 if (i == NumInitElements &&
654 Dest.isZeroed() &&
Argyrios Kyrtzidis3b4d4902011-04-28 18:53:58 +0000655 CGF.getTypes().isZeroInitializable(ElementType) &&
656 !hasNonTrivialCXXConstructor)
Chris Lattner1b726772010-12-02 07:07:26 +0000657 break;
658
Chris Lattnerf81557c2008-04-04 18:42:16 +0000659 llvm::Value *NextVal = Builder.CreateStructGEP(DestPtr, i, ".array");
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000660 LValue LV = CGF.MakeAddrLValue(NextVal, ElementType);
Chris Lattner1b726772010-12-02 07:07:26 +0000661
Chris Lattnerf81557c2008-04-04 18:42:16 +0000662 if (i < NumInitElements)
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000663 EmitInitializationToLValue(E->getInit(i), LV, ElementType);
Argyrios Kyrtzidis4423ac02011-04-21 00:27:41 +0000664 else if (Expr *filler = E->getArrayFiller())
665 EmitInitializationToLValue(filler, LV, ElementType);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000666 else
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000667 EmitNullInitializationToLValue(LV, ElementType);
Chris Lattner1b726772010-12-02 07:07:26 +0000668
669 // If the GEP didn't get used because of a dead zero init or something
670 // else, clean it up for -O0 builds and general tidiness.
671 if (llvm::GetElementPtrInst *GEP =
672 dyn_cast<llvm::GetElementPtrInst>(NextVal))
673 if (GEP->use_empty())
674 GEP->eraseFromParent();
Lauro Ramos Venancio145cd892008-02-19 19:27:31 +0000675 }
Chris Lattnerf81557c2008-04-04 18:42:16 +0000676 return;
677 }
Mike Stump1eb44332009-09-09 15:08:12 +0000678
Chris Lattnerf81557c2008-04-04 18:42:16 +0000679 assert(E->getType()->isRecordType() && "Only support structs/unions here!");
Mike Stump1eb44332009-09-09 15:08:12 +0000680
Chris Lattnerf81557c2008-04-04 18:42:16 +0000681 // Do struct initialization; this code just sets each individual member
682 // to the approprate value. This makes bitfield support automatic;
683 // the disadvantage is that the generated code is more difficult for
684 // the optimizer, especially with bitfields.
685 unsigned NumInitElements = E->getNumInits();
Ted Kremenek6217b802009-07-29 21:53:49 +0000686 RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
Chris Lattnerbd7de382010-09-06 00:13:11 +0000687
Douglas Gregor0bb76892009-01-29 16:53:55 +0000688 if (E->getType()->isUnionType()) {
689 // Only initialize one field of a union. The field itself is
690 // specified by the initializer list.
691 if (!E->getInitializedFieldInUnion()) {
692 // Empty union; we have nothing to do.
Mike Stump1eb44332009-09-09 15:08:12 +0000693
Douglas Gregor0bb76892009-01-29 16:53:55 +0000694#ifndef NDEBUG
695 // Make sure that it's really an empty and not a failure of
696 // semantic analysis.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000697 for (RecordDecl::field_iterator Field = SD->field_begin(),
698 FieldEnd = SD->field_end();
Douglas Gregor0bb76892009-01-29 16:53:55 +0000699 Field != FieldEnd; ++Field)
700 assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
701#endif
702 return;
703 }
704
705 // FIXME: volatility
706 FieldDecl *Field = E->getInitializedFieldInUnion();
Douglas Gregor0bb76892009-01-29 16:53:55 +0000707
Chris Lattner1b726772010-12-02 07:07:26 +0000708 LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestPtr, Field, 0);
Douglas Gregor0bb76892009-01-29 16:53:55 +0000709 if (NumInitElements) {
710 // Store the initializer into the field
Anders Carlsson78e83f82010-02-03 17:33:16 +0000711 EmitInitializationToLValue(E->getInit(0), FieldLoc, Field->getType());
Douglas Gregor0bb76892009-01-29 16:53:55 +0000712 } else {
Chris Lattner1b726772010-12-02 07:07:26 +0000713 // Default-initialize to null.
Douglas Gregor0bb76892009-01-29 16:53:55 +0000714 EmitNullInitializationToLValue(FieldLoc, Field->getType());
715 }
716
717 return;
718 }
Mike Stump1eb44332009-09-09 15:08:12 +0000719
Chris Lattnerf81557c2008-04-04 18:42:16 +0000720 // Here we iterate over the fields; this makes it simpler to both
721 // default-initialize fields and skip over unnamed fields.
Chris Lattnerbd7de382010-09-06 00:13:11 +0000722 unsigned CurInitVal = 0;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000723 for (RecordDecl::field_iterator Field = SD->field_begin(),
724 FieldEnd = SD->field_end();
Douglas Gregor44b43212008-12-11 16:49:14 +0000725 Field != FieldEnd; ++Field) {
726 // We're done once we hit the flexible array member
727 if (Field->getType()->isIncompleteArrayType())
728 break;
729
Douglas Gregor34e79462009-01-28 23:36:17 +0000730 if (Field->isUnnamedBitfield())
Chris Lattnerf81557c2008-04-04 18:42:16 +0000731 continue;
Douglas Gregor34e79462009-01-28 23:36:17 +0000732
Chris Lattner1b726772010-12-02 07:07:26 +0000733 // Don't emit GEP before a noop store of zero.
734 if (CurInitVal == NumInitElements && Dest.isZeroed() &&
735 CGF.getTypes().isZeroInitializable(E->getType()))
736 break;
737
Eli Friedman1e692ac2008-06-13 23:01:12 +0000738 // FIXME: volatility
Anders Carlssone78ccb42010-02-03 19:13:55 +0000739 LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestPtr, *Field, 0);
Fariborz Jahanian14674ff2009-05-27 19:54:11 +0000740 // We never generate write-barries for initialized fields.
Daniel Dunbarea619172010-08-21 03:22:38 +0000741 FieldLoc.setNonGC(true);
Chris Lattner1b726772010-12-02 07:07:26 +0000742
Chris Lattnerf81557c2008-04-04 18:42:16 +0000743 if (CurInitVal < NumInitElements) {
Chris Lattnerb35baae2010-03-08 21:08:07 +0000744 // Store the initializer into the field.
745 EmitInitializationToLValue(E->getInit(CurInitVal++), FieldLoc,
Anders Carlsson78e83f82010-02-03 17:33:16 +0000746 Field->getType());
Chris Lattnerf81557c2008-04-04 18:42:16 +0000747 } else {
748 // We're out of initalizers; default-initialize to null
Douglas Gregor44b43212008-12-11 16:49:14 +0000749 EmitNullInitializationToLValue(FieldLoc, Field->getType());
Chris Lattnerf81557c2008-04-04 18:42:16 +0000750 }
Chris Lattner1b726772010-12-02 07:07:26 +0000751
752 // If the GEP didn't get used because of a dead zero init or something
753 // else, clean it up for -O0 builds and general tidiness.
754 if (FieldLoc.isSimple())
755 if (llvm::GetElementPtrInst *GEP =
756 dyn_cast<llvm::GetElementPtrInst>(FieldLoc.getAddress()))
757 if (GEP->use_empty())
758 GEP->eraseFromParent();
Lauro Ramos Venancio145cd892008-02-19 19:27:31 +0000759 }
Devang Patel636c3d02007-10-26 17:44:44 +0000760}
761
Chris Lattneree755f92007-08-21 04:59:27 +0000762//===----------------------------------------------------------------------===//
763// Entry Points into this File
764//===----------------------------------------------------------------------===//
765
Chris Lattner1b726772010-12-02 07:07:26 +0000766/// GetNumNonZeroBytesInInit - Get an approximate count of the number of
767/// non-zero bytes that will be stored when outputting the initializer for the
768/// specified initializer expression.
Ken Dyck02c45332011-04-24 17:17:56 +0000769static CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) {
Peter Collingbournef111d932011-04-15 00:35:48 +0000770 E = E->IgnoreParens();
Chris Lattner1b726772010-12-02 07:07:26 +0000771
772 // 0 and 0.0 won't require any non-zero stores!
Ken Dyck02c45332011-04-24 17:17:56 +0000773 if (isSimpleZero(E, CGF)) return CharUnits::Zero();
Chris Lattner1b726772010-12-02 07:07:26 +0000774
775 // If this is an initlist expr, sum up the size of sizes of the (present)
776 // elements. If this is something weird, assume the whole thing is non-zero.
777 const InitListExpr *ILE = dyn_cast<InitListExpr>(E);
778 if (ILE == 0 || !CGF.getTypes().isZeroInitializable(ILE->getType()))
Ken Dyck02c45332011-04-24 17:17:56 +0000779 return CGF.getContext().getTypeSizeInChars(E->getType());
Chris Lattner1b726772010-12-02 07:07:26 +0000780
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000781 // InitListExprs for structs have to be handled carefully. If there are
782 // reference members, we need to consider the size of the reference, not the
783 // referencee. InitListExprs for unions and arrays can't have references.
Chris Lattner8c00ad12010-12-02 22:52:04 +0000784 if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
785 if (!RT->isUnionType()) {
786 RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
Ken Dyck02c45332011-04-24 17:17:56 +0000787 CharUnits NumNonZeroBytes = CharUnits::Zero();
Chris Lattner8c00ad12010-12-02 22:52:04 +0000788
789 unsigned ILEElement = 0;
790 for (RecordDecl::field_iterator Field = SD->field_begin(),
791 FieldEnd = SD->field_end(); Field != FieldEnd; ++Field) {
792 // We're done once we hit the flexible array member or run out of
793 // InitListExpr elements.
794 if (Field->getType()->isIncompleteArrayType() ||
795 ILEElement == ILE->getNumInits())
796 break;
797 if (Field->isUnnamedBitfield())
798 continue;
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000799
Chris Lattner8c00ad12010-12-02 22:52:04 +0000800 const Expr *E = ILE->getInit(ILEElement++);
801
802 // Reference values are always non-null and have the width of a pointer.
803 if (Field->getType()->isReferenceType())
Ken Dyck02c45332011-04-24 17:17:56 +0000804 NumNonZeroBytes += CGF.getContext().toCharUnitsFromBits(
805 CGF.getContext().Target.getPointerWidth(0));
Chris Lattner8c00ad12010-12-02 22:52:04 +0000806 else
807 NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF);
808 }
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000809
Chris Lattner8c00ad12010-12-02 22:52:04 +0000810 return NumNonZeroBytes;
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000811 }
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000812 }
813
814
Ken Dyck02c45332011-04-24 17:17:56 +0000815 CharUnits NumNonZeroBytes = CharUnits::Zero();
Chris Lattner1b726772010-12-02 07:07:26 +0000816 for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
817 NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF);
818 return NumNonZeroBytes;
819}
820
821/// CheckAggExprForMemSetUse - If the initializer is large and has a lot of
822/// zeros in it, emit a memset and avoid storing the individual zeros.
823///
824static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,
825 CodeGenFunction &CGF) {
826 // If the slot is already known to be zeroed, nothing to do. Don't mess with
827 // volatile stores.
828 if (Slot.isZeroed() || Slot.isVolatile() || Slot.getAddr() == 0) return;
Argyrios Kyrtzidis657baf12011-04-28 22:57:55 +0000829
830 // C++ objects with a user-declared constructor don't need zero'ing.
831 if (CGF.getContext().getLangOptions().CPlusPlus)
832 if (const RecordType *RT = CGF.getContext()
833 .getBaseElementType(E->getType())->getAs<RecordType>()) {
834 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
835 if (RD->hasUserDeclaredConstructor())
836 return;
837 }
838
Chris Lattner1b726772010-12-02 07:07:26 +0000839 // If the type is 16-bytes or smaller, prefer individual stores over memset.
Ken Dyck5ff1a352011-04-24 17:25:32 +0000840 std::pair<CharUnits, CharUnits> TypeInfo =
841 CGF.getContext().getTypeInfoInChars(E->getType());
842 if (TypeInfo.first <= CharUnits::fromQuantity(16))
Chris Lattner1b726772010-12-02 07:07:26 +0000843 return;
844
845 // Check to see if over 3/4 of the initializer are known to be zero. If so,
846 // we prefer to emit memset + individual stores for the rest.
Ken Dyck5ff1a352011-04-24 17:25:32 +0000847 CharUnits NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF);
848 if (NumNonZeroBytes*4 > TypeInfo.first)
Chris Lattner1b726772010-12-02 07:07:26 +0000849 return;
850
851 // Okay, it seems like a good idea to use an initial memset, emit the call.
Ken Dyck5ff1a352011-04-24 17:25:32 +0000852 llvm::Constant *SizeVal = CGF.Builder.getInt64(TypeInfo.first.getQuantity());
853 CharUnits Align = TypeInfo.second;
Chris Lattner1b726772010-12-02 07:07:26 +0000854
855 llvm::Value *Loc = Slot.getAddr();
856 const llvm::Type *BP = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
857
858 Loc = CGF.Builder.CreateBitCast(Loc, BP);
Ken Dyck5ff1a352011-04-24 17:25:32 +0000859 CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal,
860 Align.getQuantity(), false);
Chris Lattner1b726772010-12-02 07:07:26 +0000861
862 // Tell the AggExprEmitter that the slot is known zero.
863 Slot.setZeroed();
864}
865
866
867
868
Mike Stumpe1129a92009-05-26 18:57:45 +0000869/// EmitAggExpr - Emit the computation of the specified expression of aggregate
870/// type. The result is computed into DestPtr. Note that if DestPtr is null,
871/// the value of the aggregate expression is not needed. If VolatileDest is
872/// true, DestPtr cannot be 0.
John McCall558d2ab2010-09-15 10:14:12 +0000873///
874/// \param IsInitializer - true if this evaluation is initializing an
875/// object whose lifetime is already being managed.
Daniel Dunbar18aba0d2010-02-05 19:38:31 +0000876//
877// FIXME: Take Qualifiers object.
John McCall558d2ab2010-09-15 10:14:12 +0000878void CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot,
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000879 bool IgnoreResult) {
Chris Lattneree755f92007-08-21 04:59:27 +0000880 assert(E && hasAggregateLLVMType(E->getType()) &&
881 "Invalid aggregate expression to emit");
Chris Lattner1b726772010-12-02 07:07:26 +0000882 assert((Slot.getAddr() != 0 || Slot.isIgnored()) &&
883 "slot has bits but no address");
Mike Stump1eb44332009-09-09 15:08:12 +0000884
Chris Lattner1b726772010-12-02 07:07:26 +0000885 // Optimize the slot if possible.
886 CheckAggExprForMemSetUse(Slot, E, *this);
887
888 AggExprEmitter(*this, Slot, IgnoreResult).Visit(const_cast<Expr*>(E));
Chris Lattneree755f92007-08-21 04:59:27 +0000889}
Daniel Dunbar7482d122008-09-09 20:49:46 +0000890
Daniel Dunbar18aba0d2010-02-05 19:38:31 +0000891LValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) {
892 assert(hasAggregateLLVMType(E->getType()) && "Invalid argument!");
Daniel Dunbar195337d2010-02-09 02:48:28 +0000893 llvm::Value *Temp = CreateMemTemp(E->getType());
Daniel Dunbar79c39282010-08-21 03:15:20 +0000894 LValue LV = MakeAddrLValue(Temp, E->getType());
Chris Lattner1b726772010-12-02 07:07:26 +0000895 EmitAggExpr(E, AggValueSlot::forAddr(Temp, LV.isVolatileQualified(), false));
Daniel Dunbar79c39282010-08-21 03:15:20 +0000896 return LV;
Daniel Dunbar18aba0d2010-02-05 19:38:31 +0000897}
898
Daniel Dunbar7482d122008-09-09 20:49:46 +0000899void CodeGenFunction::EmitAggregateCopy(llvm::Value *DestPtr,
Mike Stump27fe2e62009-05-23 22:29:41 +0000900 llvm::Value *SrcPtr, QualType Ty,
901 bool isVolatile) {
Daniel Dunbar7482d122008-09-09 20:49:46 +0000902 assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
Mike Stump1eb44332009-09-09 15:08:12 +0000903
Anders Carlsson0d7c5832010-05-03 01:20:20 +0000904 if (getContext().getLangOptions().CPlusPlus) {
905 if (const RecordType *RT = Ty->getAs<RecordType>()) {
Douglas Gregore9979482010-05-20 15:39:01 +0000906 CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
907 assert((Record->hasTrivialCopyConstructor() ||
Fariborz Jahanian1d49f212010-05-20 16:46:55 +0000908 Record->hasTrivialCopyAssignment()) &&
Douglas Gregore9979482010-05-20 15:39:01 +0000909 "Trying to aggregate-copy a type without a trivial copy "
910 "constructor or assignment operator");
Douglas Gregor419aa962010-05-20 15:48:29 +0000911 // Ignore empty classes in C++.
Douglas Gregore9979482010-05-20 15:39:01 +0000912 if (Record->isEmpty())
Anders Carlsson0d7c5832010-05-03 01:20:20 +0000913 return;
914 }
915 }
916
Chris Lattner83c96292009-02-28 18:31:01 +0000917 // Aggregate assignment turns into llvm.memcpy. This is almost valid per
Chris Lattnerca4fc2c2009-02-28 18:18:58 +0000918 // C99 6.5.16.1p3, which states "If the value being stored in an object is
919 // read from another object that overlaps in anyway the storage of the first
920 // object, then the overlap shall be exact and the two objects shall have
921 // qualified or unqualified versions of a compatible type."
922 //
Chris Lattner83c96292009-02-28 18:31:01 +0000923 // memcpy is not defined if the source and destination pointers are exactly
Chris Lattnerca4fc2c2009-02-28 18:18:58 +0000924 // equal, but other compilers do this optimization, and almost every memcpy
925 // implementation handles this case safely. If there is a libc that does not
926 // safely handle this, we can add a target hook.
Mike Stump1eb44332009-09-09 15:08:12 +0000927
Daniel Dunbar7482d122008-09-09 20:49:46 +0000928 // Get size and alignment info for this aggregate.
Ken Dyck1a8c15a2011-04-24 17:37:26 +0000929 std::pair<CharUnits, CharUnits> TypeInfo =
930 getContext().getTypeInfoInChars(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +0000931
Daniel Dunbar7482d122008-09-09 20:49:46 +0000932 // FIXME: Handle variable sized types.
Mike Stump1eb44332009-09-09 15:08:12 +0000933
Mike Stumpfde64202009-05-23 04:13:59 +0000934 // FIXME: If we have a volatile struct, the optimizer can remove what might
935 // appear to be `extra' memory ops:
936 //
937 // volatile struct { int i; } a, b;
938 //
939 // int main() {
940 // a = b;
941 // a = b;
942 // }
943 //
Mon P Wang3ecd7852010-04-04 03:10:52 +0000944 // we need to use a different call here. We use isVolatile to indicate when
Mike Stump49d1cd52009-05-26 22:03:21 +0000945 // either the source or the destination is volatile.
Mon P Wang3ecd7852010-04-04 03:10:52 +0000946
947 const llvm::PointerType *DPT = cast<llvm::PointerType>(DestPtr->getType());
Chris Lattner098432c2010-07-08 00:07:45 +0000948 const llvm::Type *DBP =
John McCalld16c2cf2011-02-08 08:22:06 +0000949 llvm::Type::getInt8PtrTy(getLLVMContext(), DPT->getAddressSpace());
Chris Lattner098432c2010-07-08 00:07:45 +0000950 DestPtr = Builder.CreateBitCast(DestPtr, DBP, "tmp");
Mon P Wang3ecd7852010-04-04 03:10:52 +0000951
952 const llvm::PointerType *SPT = cast<llvm::PointerType>(SrcPtr->getType());
Chris Lattner098432c2010-07-08 00:07:45 +0000953 const llvm::Type *SBP =
John McCalld16c2cf2011-02-08 08:22:06 +0000954 llvm::Type::getInt8PtrTy(getLLVMContext(), SPT->getAddressSpace());
Chris Lattner098432c2010-07-08 00:07:45 +0000955 SrcPtr = Builder.CreateBitCast(SrcPtr, SBP, "tmp");
Mon P Wang3ecd7852010-04-04 03:10:52 +0000956
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000957 if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
958 RecordDecl *Record = RecordTy->getDecl();
959 if (Record->hasObjectMember()) {
Ken Dyck1a8c15a2011-04-24 17:37:26 +0000960 CharUnits size = TypeInfo.first;
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000961 const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
Ken Dyck1a8c15a2011-04-24 17:37:26 +0000962 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size.getQuantity());
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000963 CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
964 SizeVal);
965 return;
966 }
967 } else if (getContext().getAsArrayType(Ty)) {
968 QualType BaseType = getContext().getBaseElementType(Ty);
969 if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
970 if (RecordTy->getDecl()->hasObjectMember()) {
Ken Dyck1a8c15a2011-04-24 17:37:26 +0000971 CharUnits size = TypeInfo.first;
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000972 const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
Ken Dyck1a8c15a2011-04-24 17:37:26 +0000973 llvm::Value *SizeVal =
974 llvm::ConstantInt::get(SizeTy, size.getQuantity());
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000975 CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
976 SizeVal);
977 return;
978 }
979 }
980 }
981
Benjamin Kramer9f0c7cc2010-12-30 00:13:21 +0000982 Builder.CreateMemCpy(DestPtr, SrcPtr,
Ken Dyck1a8c15a2011-04-24 17:37:26 +0000983 llvm::ConstantInt::get(IntPtrTy,
984 TypeInfo.first.getQuantity()),
985 TypeInfo.second.getQuantity(), isVolatile);
Daniel Dunbar7482d122008-09-09 20:49:46 +0000986}