blob: 9e4e7dcc534a5a4979c1b37bc2ae6c4721911279 [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()); }
Eli Friedman12444a22009-01-27 09:03:41 +000084 void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
Chris Lattner9c033562007-08-21 04:25:47 +000085
86 // l-values.
Seo Sanghyeon9b73b392007-12-14 02:04:12 +000087 void VisitDeclRefExpr(DeclRefExpr *DRE) { EmitAggLoadOfLValue(DRE); }
88 void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }
89 void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
Daniel Dunbar5be028f2010-01-04 18:47:06 +000090 void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }
Chris Lattnerf0a990c2009-04-21 23:00:09 +000091 void VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
Mike Stump1eb44332009-09-09 15:08:12 +000092 EmitAggLoadOfLValue(E);
Chris Lattnerf0a990c2009-04-21 23:00:09 +000093 }
Seo Sanghyeon9b73b392007-12-14 02:04:12 +000094 void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
95 EmitAggLoadOfLValue(E);
96 }
Chris Lattnerf0a990c2009-04-21 23:00:09 +000097 void VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) {
Mike Stump1eb44332009-09-09 15:08:12 +000098 EmitAggLoadOfLValue(E);
Chris Lattnerf0a990c2009-04-21 23:00:09 +000099 }
100 void VisitPredefinedExpr(const PredefinedExpr *E) {
Mike Stump1eb44332009-09-09 15:08:12 +0000101 EmitAggLoadOfLValue(E);
Chris Lattnerf0a990c2009-04-21 23:00:09 +0000102 }
Mike Stump1eb44332009-09-09 15:08:12 +0000103
Chris Lattner9c033562007-08-21 04:25:47 +0000104 // Operators.
Anders Carlsson4d8673b2009-08-07 23:22:37 +0000105 void VisitCastExpr(CastExpr *E);
Anders Carlsson148fe672007-10-31 22:04:46 +0000106 void VisitCallExpr(const CallExpr *E);
Chris Lattnerb2d963f2007-08-31 22:54:14 +0000107 void VisitStmtExpr(const StmtExpr *E);
Chris Lattner9c033562007-08-21 04:25:47 +0000108 void VisitBinaryOperator(const BinaryOperator *BO);
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +0000109 void VisitPointerToDataMemberBinaryOperator(const BinaryOperator *BO);
Chris Lattner03d6fb92007-08-21 04:43:17 +0000110 void VisitBinAssign(const BinaryOperator *E);
Eli Friedman07fa52a2008-05-20 07:56:31 +0000111 void VisitBinComma(const BinaryOperator *E);
Chris Lattner9c033562007-08-21 04:25:47 +0000112
Chris Lattner8fdf3282008-06-24 17:04:18 +0000113 void VisitObjCMessageExpr(ObjCMessageExpr *E);
Daniel Dunbar0a04d772008-08-23 10:51:21 +0000114 void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
115 EmitAggLoadOfLValue(E);
116 }
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000117 void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
Mike Stump1eb44332009-09-09 15:08:12 +0000118
Chris Lattner9c033562007-08-21 04:25:47 +0000119 void VisitConditionalOperator(const ConditionalOperator *CO);
Anders Carlssona294ca82009-07-08 18:33:14 +0000120 void VisitChooseExpr(const ChooseExpr *CE);
Devang Patel636c3d02007-10-26 17:44:44 +0000121 void VisitInitListExpr(InitListExpr *E);
Anders Carlsson30311fa2009-12-16 06:57:54 +0000122 void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
Chris Lattner04421082008-04-08 04:40:51 +0000123 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
124 Visit(DAE->getExpr());
125 }
Anders Carlssonb58d0172009-05-30 23:23:33 +0000126 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
Anders Carlsson31ccf372009-05-03 17:47:16 +0000127 void VisitCXXConstructExpr(const CXXConstructExpr *E);
Anders Carlsson7f6ad152009-05-19 04:48:36 +0000128 void VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E);
Douglas Gregored8abf12010-07-08 06:14:04 +0000129 void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
Mike Stump2710c412009-11-18 00:40:12 +0000130 void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); }
Anders Carlsson7f6ad152009-05-19 04:48:36 +0000131
Eli Friedmanb1851242008-05-27 15:51:49 +0000132 void VisitVAArgExpr(VAArgExpr *E);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000133
Anders Carlsson78e83f82010-02-03 17:33:16 +0000134 void EmitInitializationToLValue(Expr *E, LValue Address, QualType T);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000135 void EmitNullInitializationToLValue(LValue Address, QualType T);
Chris Lattner9c033562007-08-21 04:25:47 +0000136 // case Expr::ChooseExprClass:
Mike Stump39406b12009-12-09 19:24:08 +0000137 void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
Chris Lattner9c033562007-08-21 04:25:47 +0000138};
139} // end anonymous namespace.
140
Chris Lattneree755f92007-08-21 04:59:27 +0000141//===----------------------------------------------------------------------===//
142// Utilities
143//===----------------------------------------------------------------------===//
Chris Lattner9c033562007-08-21 04:25:47 +0000144
Chris Lattner883f6a72007-08-11 00:04:45 +0000145/// EmitAggLoadOfLValue - Given an expression with aggregate type that
146/// represents a value lvalue, this method emits the address of the lvalue,
147/// then loads the result into DestPtr.
Chris Lattner9c033562007-08-21 04:25:47 +0000148void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
149 LValue LV = CGF.EmitLValue(E);
Mike Stump4ac20dd2009-05-23 20:28:01 +0000150 EmitFinalDestCopy(E, LV);
151}
152
John McCallfa037bd2010-05-22 22:13:32 +0000153/// \brief True if the given aggregate type requires special GC API calls.
154bool AggExprEmitter::TypeRequiresGCollection(QualType T) {
155 // Only record types have members that might require garbage collection.
156 const RecordType *RecordTy = T->getAs<RecordType>();
157 if (!RecordTy) return false;
158
159 // Don't mess with non-trivial C++ types.
160 RecordDecl *Record = RecordTy->getDecl();
161 if (isa<CXXRecordDecl>(Record) &&
162 (!cast<CXXRecordDecl>(Record)->hasTrivialCopyConstructor() ||
163 !cast<CXXRecordDecl>(Record)->hasTrivialDestructor()))
164 return false;
165
166 // Check whether the type has an object member.
167 return Record->hasObjectMember();
168}
169
170/// \brief Perform the final move to DestPtr if RequiresGCollection is set.
171///
172/// The idea is that you do something like this:
173/// RValue Result = EmitSomething(..., getReturnValueSlot());
174/// EmitGCMove(E, Result);
175/// If GC doesn't interfere, this will cause the result to be emitted
176/// directly into the return value slot. If GC does interfere, a final
177/// move will be performed.
178void AggExprEmitter::EmitGCMove(const Expr *E, RValue Src) {
John McCalld1a5f132010-09-16 03:13:23 +0000179 if (Dest.requiresGCollection()) {
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000180 std::pair<uint64_t, unsigned> TypeInfo =
181 CGF.getContext().getTypeInfo(E->getType());
182 unsigned long size = TypeInfo.first/8;
183 const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
184 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size);
John McCall558d2ab2010-09-15 10:14:12 +0000185 CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF, Dest.getAddr(),
John McCallfa037bd2010-05-22 22:13:32 +0000186 Src.getAggregateAddr(),
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000187 SizeVal);
188 }
John McCallfa037bd2010-05-22 22:13:32 +0000189}
190
Mike Stump4ac20dd2009-05-23 20:28:01 +0000191/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
Mike Stump49d1cd52009-05-26 22:03:21 +0000192void AggExprEmitter::EmitFinalDestCopy(const Expr *E, RValue Src, bool Ignore) {
Mike Stump4ac20dd2009-05-23 20:28:01 +0000193 assert(Src.isAggregate() && "value must be aggregate value!");
194
John McCall558d2ab2010-09-15 10:14:12 +0000195 // If Dest is ignored, then we're evaluating an aggregate expression
John McCalla8f28da2010-08-25 02:50:31 +0000196 // in a context (like an expression statement) that doesn't care
197 // about the result. C says that an lvalue-to-rvalue conversion is
198 // performed in these cases; C++ says that it is not. In either
199 // case, we don't actually need to do anything unless the value is
200 // volatile.
John McCall558d2ab2010-09-15 10:14:12 +0000201 if (Dest.isIgnored()) {
John McCalla8f28da2010-08-25 02:50:31 +0000202 if (!Src.isVolatileQualified() ||
203 CGF.CGM.getLangOptions().CPlusPlus ||
204 (IgnoreResult && Ignore))
Mike Stump9ccb1032009-05-23 22:01:27 +0000205 return;
Fariborz Jahanian8a970052010-10-22 22:05:03 +0000206
Mike Stump49d1cd52009-05-26 22:03:21 +0000207 // If the source is volatile, we must read from it; to do that, we need
208 // some place to put it.
John McCall558d2ab2010-09-15 10:14:12 +0000209 Dest = CGF.CreateAggTemp(E->getType(), "agg.tmp");
Mike Stump9ccb1032009-05-23 22:01:27 +0000210 }
Chris Lattner883f6a72007-08-11 00:04:45 +0000211
John McCalld1a5f132010-09-16 03:13:23 +0000212 if (Dest.requiresGCollection()) {
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000213 std::pair<uint64_t, unsigned> TypeInfo =
214 CGF.getContext().getTypeInfo(E->getType());
215 unsigned long size = TypeInfo.first/8;
216 const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
217 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size);
Fariborz Jahanian08c32132009-08-31 19:33:16 +0000218 CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF,
John McCall558d2ab2010-09-15 10:14:12 +0000219 Dest.getAddr(),
220 Src.getAggregateAddr(),
221 SizeVal);
Fariborz Jahanian08c32132009-08-31 19:33:16 +0000222 return;
223 }
Mike Stump4ac20dd2009-05-23 20:28:01 +0000224 // If the result of the assignment is used, copy the LHS there also.
225 // FIXME: Pass VolatileDest as well. I think we also need to merge volatile
226 // from the source as well, as we can't eliminate it if either operand
227 // is volatile, unless copy has volatile for both source and destination..
John McCall558d2ab2010-09-15 10:14:12 +0000228 CGF.EmitAggregateCopy(Dest.getAddr(), Src.getAggregateAddr(), E->getType(),
229 Dest.isVolatile()|Src.isVolatileQualified());
Mike Stump4ac20dd2009-05-23 20:28:01 +0000230}
231
232/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
Mike Stump49d1cd52009-05-26 22:03:21 +0000233void AggExprEmitter::EmitFinalDestCopy(const Expr *E, LValue Src, bool Ignore) {
Mike Stump4ac20dd2009-05-23 20:28:01 +0000234 assert(Src.isSimple() && "Can't have aggregate bitfield, vector, etc");
235
236 EmitFinalDestCopy(E, RValue::getAggregate(Src.getAddress(),
Mike Stump49d1cd52009-05-26 22:03:21 +0000237 Src.isVolatileQualified()),
238 Ignore);
Chris Lattner883f6a72007-08-11 00:04:45 +0000239}
240
Chris Lattneree755f92007-08-21 04:59:27 +0000241//===----------------------------------------------------------------------===//
242// Visitor Methods
243//===----------------------------------------------------------------------===//
244
Anders Carlsson4d8673b2009-08-07 23:22:37 +0000245void AggExprEmitter::VisitCastExpr(CastExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000246 if (Dest.isIgnored() && E->getCastKind() != CK_Dynamic) {
Douglas Gregor4ce46c22010-03-07 23:24:59 +0000247 Visit(E->getSubExpr());
248 return;
249 }
250
Anders Carlsson30168422009-09-29 01:23:39 +0000251 switch (E->getCastKind()) {
John McCall2de56d12010-08-25 11:45:40 +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: {
Anders Carlsson4d8673b2009-08-07 23:22:37 +0000267 // GCC union extension
Daniel Dunbar79c39282010-08-21 03:15:20 +0000268 QualType Ty = E->getSubExpr()->getType();
269 QualType PtrTy = CGF.getContext().getPointerType(Ty);
John McCall558d2ab2010-09-15 10:14:12 +0000270 llvm::Value *CastPtr = Builder.CreateBitCast(Dest.getAddr(),
Eli Friedman34ebf4d2009-06-03 20:45:06 +0000271 CGF.ConvertType(PtrTy));
Daniel Dunbar79c39282010-08-21 03:15:20 +0000272 EmitInitializationToLValue(E->getSubExpr(), CGF.MakeAddrLValue(CastPtr, Ty),
273 Ty);
Anders Carlsson30168422009-09-29 01:23:39 +0000274 break;
Nuno Lopes7e916272009-01-15 20:14:33 +0000275 }
Mike Stump1eb44332009-09-09 15:08:12 +0000276
John McCall2de56d12010-08-25 11:45:40 +0000277 case CK_DerivedToBase:
278 case CK_BaseToDerived:
279 case CK_UncheckedDerivedToBase: {
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000280 assert(0 && "cannot perform hierarchy conversion in EmitAggExpr: "
281 "should have been unpacked before we got here");
282 break;
283 }
284
John McCall2de56d12010-08-25 11:45:40 +0000285 case CK_NoOp:
John McCall0ae287a2010-12-01 04:43:34 +0000286 case CK_LValueToRValue:
John McCall2de56d12010-08-25 11:45:40 +0000287 case CK_UserDefinedConversion:
288 case CK_ConstructorConversion:
Anders Carlsson30168422009-09-29 01:23:39 +0000289 assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(),
290 E->getType()) &&
291 "Implicit cast types must be compatible");
292 Visit(E->getSubExpr());
293 break;
John McCall0ae287a2010-12-01 04:43:34 +0000294
John McCall2de56d12010-08-25 11:45:40 +0000295 case CK_LValueBitCast:
John McCall0ae287a2010-12-01 04:43:34 +0000296 llvm_unreachable("should not be emitting lvalue bitcast as rvalue");
Douglas Gregore39a3892010-07-13 23:17:26 +0000297 break;
John McCall0ae287a2010-12-01 04:43:34 +0000298
299 case CK_Dependent:
300 case CK_BitCast:
301 case CK_ArrayToPointerDecay:
302 case CK_FunctionToPointerDecay:
303 case CK_NullToPointer:
304 case CK_NullToMemberPointer:
305 case CK_BaseToDerivedMemberPointer:
306 case CK_DerivedToBaseMemberPointer:
307 case CK_MemberPointerToBoolean:
308 case CK_IntegralToPointer:
309 case CK_PointerToIntegral:
310 case CK_PointerToBoolean:
311 case CK_ToVoid:
312 case CK_VectorSplat:
313 case CK_IntegralCast:
314 case CK_IntegralToBoolean:
315 case CK_IntegralToFloating:
316 case CK_FloatingToIntegral:
317 case CK_FloatingToBoolean:
318 case CK_FloatingCast:
319 case CK_AnyPointerToObjCPointerCast:
320 case CK_AnyPointerToBlockPointerCast:
321 case CK_ObjCObjectLValueCast:
322 case CK_FloatingRealToComplex:
323 case CK_FloatingComplexToReal:
324 case CK_FloatingComplexToBoolean:
325 case CK_FloatingComplexCast:
326 case CK_FloatingComplexToIntegralComplex:
327 case CK_IntegralRealToComplex:
328 case CK_IntegralComplexToReal:
329 case CK_IntegralComplexToBoolean:
330 case CK_IntegralComplexCast:
331 case CK_IntegralComplexToFloatingComplex:
332 llvm_unreachable("cast kind invalid for aggregate types");
Anders Carlsson30168422009-09-29 01:23:39 +0000333 }
Anders Carlssone4707ff2008-01-14 06:28:57 +0000334}
335
Chris Lattner96196622008-07-26 22:37:01 +0000336void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
Anders Carlssone70e8f72009-05-27 16:45:02 +0000337 if (E->getCallReturnType()->isReferenceType()) {
338 EmitAggLoadOfLValue(E);
339 return;
340 }
Mike Stump1eb44332009-09-09 15:08:12 +0000341
John McCallfa037bd2010-05-22 22:13:32 +0000342 RValue RV = CGF.EmitCallExpr(E, getReturnValueSlot());
343 EmitGCMove(E, RV);
Anders Carlsson148fe672007-10-31 22:04:46 +0000344}
Chris Lattner96196622008-07-26 22:37:01 +0000345
346void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
John McCallfa037bd2010-05-22 22:13:32 +0000347 RValue RV = CGF.EmitObjCMessageExpr(E, getReturnValueSlot());
348 EmitGCMove(E, RV);
Chris Lattner8fdf3282008-06-24 17:04:18 +0000349}
Anders Carlsson148fe672007-10-31 22:04:46 +0000350
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000351void AggExprEmitter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
John McCall119a1c62010-12-04 02:32:38 +0000352 RValue RV = CGF.EmitLoadOfPropertyRefLValue(CGF.EmitObjCPropertyRefLValue(E),
353 getReturnValueSlot());
John McCallfa037bd2010-05-22 22:13:32 +0000354 EmitGCMove(E, RV);
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000355}
356
Chris Lattner96196622008-07-26 22:37:01 +0000357void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000358 CGF.EmitAnyExpr(E->getLHS(), AggValueSlot::ignored(), true);
359 Visit(E->getRHS());
Eli Friedman07fa52a2008-05-20 07:56:31 +0000360}
361
Chris Lattnerb2d963f2007-08-31 22:54:14 +0000362void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000363 CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest);
Chris Lattnerb2d963f2007-08-31 22:54:14 +0000364}
365
Chris Lattner9c033562007-08-21 04:25:47 +0000366void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
John McCall2de56d12010-08-25 11:45:40 +0000367 if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI)
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +0000368 VisitPointerToDataMemberBinaryOperator(E);
369 else
370 CGF.ErrorUnsupported(E, "aggregate binary expression");
371}
372
373void AggExprEmitter::VisitPointerToDataMemberBinaryOperator(
374 const BinaryOperator *E) {
375 LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E);
376 EmitFinalDestCopy(E, LV);
Chris Lattneree755f92007-08-21 04:59:27 +0000377}
378
Chris Lattner03d6fb92007-08-21 04:43:17 +0000379void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
Eli Friedmanff6e2b72008-02-11 01:09:17 +0000380 // For an assignment to work, the value on the right has
381 // to be compatible with the value on the left.
Eli Friedman2dce5f82009-05-28 23:04:00 +0000382 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
383 E->getRHS()->getType())
Eli Friedmanff6e2b72008-02-11 01:09:17 +0000384 && "Invalid assignment");
Chris Lattner9c033562007-08-21 04:25:47 +0000385 LValue LHS = CGF.EmitLValue(E->getLHS());
Chris Lattner883f6a72007-08-11 00:04:45 +0000386
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000387 // We have to special case property setters, otherwise we must have
388 // a simple lvalue (no aggregates inside vectors, bitfields).
389 if (LHS.isPropertyRef()) {
John McCall558d2ab2010-09-15 10:14:12 +0000390 AggValueSlot Slot = EnsureSlot(E->getRHS()->getType());
391 CGF.EmitAggExpr(E->getRHS(), Slot);
John McCall119a1c62010-12-04 02:32:38 +0000392 CGF.EmitStoreThroughPropertyRefLValue(Slot.asRValue(), LHS);
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000393 } else {
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000394 bool GCollection = false;
John McCallfa037bd2010-05-22 22:13:32 +0000395 if (CGF.getContext().getLangOptions().getGCMode())
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000396 GCollection = TypeRequiresGCollection(E->getLHS()->getType());
John McCallfa037bd2010-05-22 22:13:32 +0000397
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000398 // Codegen the RHS so that it stores directly into the LHS.
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000399 AggValueSlot LHSSlot = AggValueSlot::forLValue(LHS, true,
400 GCollection);
401 CGF.EmitAggExpr(E->getRHS(), LHSSlot, false);
Mike Stump49d1cd52009-05-26 22:03:21 +0000402 EmitFinalDestCopy(E, LHS, true);
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000403 }
Chris Lattner883f6a72007-08-11 00:04:45 +0000404}
405
Chris Lattner9c033562007-08-21 04:25:47 +0000406void AggExprEmitter::VisitConditionalOperator(const ConditionalOperator *E) {
Eli Friedman8e274bd2009-12-25 06:17:05 +0000407 if (!E->getLHS()) {
408 CGF.ErrorUnsupported(E, "conditional operator with missing LHS");
409 return;
410 }
411
Daniel Dunbar9615ecb2008-11-13 01:38:36 +0000412 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
413 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
414 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
Mike Stump1eb44332009-09-09 15:08:12 +0000415
Eli Friedman8e274bd2009-12-25 06:17:05 +0000416 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000417
Anders Carlsson72119a82010-02-04 17:18:07 +0000418 CGF.BeginConditionalBranch();
Chris Lattner9c033562007-08-21 04:25:47 +0000419 CGF.EmitBlock(LHSBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000420
John McCall74fb0ed2010-11-17 00:07:33 +0000421 // Save whether the destination's lifetime is externally managed.
422 bool DestLifetimeManaged = Dest.isLifetimeExternallyManaged();
Chris Lattner883f6a72007-08-11 00:04:45 +0000423
Chris Lattnerc748f272007-08-21 05:02:10 +0000424 Visit(E->getLHS());
Anders Carlsson72119a82010-02-04 17:18:07 +0000425 CGF.EndConditionalBranch();
Daniel Dunbard57a8712008-11-11 09:41:28 +0000426 CGF.EmitBranch(ContBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000427
Anders Carlsson72119a82010-02-04 17:18:07 +0000428 CGF.BeginConditionalBranch();
Chris Lattner9c033562007-08-21 04:25:47 +0000429 CGF.EmitBlock(RHSBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000430
John McCall74fb0ed2010-11-17 00:07:33 +0000431 // If the result of an agg expression is unused, then the emission
432 // of the LHS might need to create a destination slot. That's fine
433 // with us, and we can safely emit the RHS into the same slot, but
434 // we shouldn't claim that its lifetime is externally managed.
435 Dest.setLifetimeExternallyManaged(DestLifetimeManaged);
436
Chris Lattnerc748f272007-08-21 05:02:10 +0000437 Visit(E->getRHS());
Anders Carlsson72119a82010-02-04 17:18:07 +0000438 CGF.EndConditionalBranch();
Daniel Dunbard57a8712008-11-11 09:41:28 +0000439 CGF.EmitBranch(ContBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000440
Chris Lattner9c033562007-08-21 04:25:47 +0000441 CGF.EmitBlock(ContBlock);
Chris Lattner883f6a72007-08-11 00:04:45 +0000442}
Chris Lattneree755f92007-08-21 04:59:27 +0000443
Anders Carlssona294ca82009-07-08 18:33:14 +0000444void AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) {
445 Visit(CE->getChosenSubExpr(CGF.getContext()));
446}
447
Eli Friedmanb1851242008-05-27 15:51:49 +0000448void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
Daniel Dunbar07855702009-02-11 22:25:55 +0000449 llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr());
Anders Carlssonddf7cac2008-11-04 05:30:00 +0000450 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType());
451
Sebastian Redl0262f022009-01-09 21:09:38 +0000452 if (!ArgPtr) {
Anders Carlssonddf7cac2008-11-04 05:30:00 +0000453 CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
Sebastian Redl0262f022009-01-09 21:09:38 +0000454 return;
455 }
456
Daniel Dunbar79c39282010-08-21 03:15:20 +0000457 EmitFinalDestCopy(VE, CGF.MakeAddrLValue(ArgPtr, VE->getType()));
Eli Friedmanb1851242008-05-27 15:51:49 +0000458}
459
Anders Carlssonb58d0172009-05-30 23:23:33 +0000460void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000461 // Ensure that we have a slot, but if we already do, remember
462 // whether its lifetime was externally managed.
463 bool WasManaged = Dest.isLifetimeExternallyManaged();
464 Dest = EnsureSlot(E->getType());
465 Dest.setLifetimeExternallyManaged();
Mike Stump1eb44332009-09-09 15:08:12 +0000466
John McCall558d2ab2010-09-15 10:14:12 +0000467 Visit(E->getSubExpr());
Anders Carlssonb58d0172009-05-30 23:23:33 +0000468
John McCall558d2ab2010-09-15 10:14:12 +0000469 // Set up the temporary's destructor if its lifetime wasn't already
470 // being managed.
471 if (!WasManaged)
472 CGF.EmitCXXTemporary(E->getTemporary(), Dest.getAddr());
Anders Carlssonb58d0172009-05-30 23:23:33 +0000473}
474
Anders Carlssonb14095a2009-04-17 00:06:03 +0000475void
Anders Carlsson31ccf372009-05-03 17:47:16 +0000476AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000477 AggValueSlot Slot = EnsureSlot(E->getType());
478 CGF.EmitCXXConstructExpr(E, Slot);
Anders Carlsson7f6ad152009-05-19 04:48:36 +0000479}
480
481void AggExprEmitter::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000482 CGF.EmitCXXExprWithTemporaries(E, Dest);
Anders Carlssonb14095a2009-04-17 00:06:03 +0000483}
484
Douglas Gregored8abf12010-07-08 06:14:04 +0000485void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000486 QualType T = E->getType();
487 AggValueSlot Slot = EnsureSlot(T);
488 EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T), T);
Anders Carlsson30311fa2009-12-16 06:57:54 +0000489}
490
491void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000492 QualType T = E->getType();
493 AggValueSlot Slot = EnsureSlot(T);
494 EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T), T);
Nuno Lopes329763b2009-10-18 15:18:11 +0000495}
496
Chris Lattner1b726772010-12-02 07:07:26 +0000497/// isSimpleZero - If emitting this value will obviously just cause a store of
498/// zero to memory, return true. This can return false if uncertain, so it just
499/// handles simple cases.
500static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {
501 // (0)
502 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E))
503 return isSimpleZero(PE->getSubExpr(), CGF);
504 // 0
505 if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
506 return IL->getValue() == 0;
507 // +0.0
508 if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E))
509 return FL->getValue().isPosZero();
510 // int()
511 if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) &&
512 CGF.getTypes().isZeroInitializable(E->getType()))
513 return true;
514 // (int*)0 - Null pointer expressions.
515 if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
516 return ICE->getCastKind() == CK_NullToPointer;
517 // '\0'
518 if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E))
519 return CL->getValue() == 0;
520
521 // Otherwise, hard case: conservatively return false.
522 return false;
523}
524
525
Anders Carlsson78e83f82010-02-03 17:33:16 +0000526void
527AggExprEmitter::EmitInitializationToLValue(Expr* E, LValue LV, QualType T) {
Mike Stump7f79f9b2009-05-29 15:46:01 +0000528 // FIXME: Ignore result?
Chris Lattnerf81557c2008-04-04 18:42:16 +0000529 // FIXME: Are initializers affected by volatile?
Chris Lattner1b726772010-12-02 07:07:26 +0000530 if (Dest.isZeroed() && isSimpleZero(E, CGF)) {
531 // Storing "i32 0" to a zero'd memory location is a noop.
532 } else if (isa<ImplicitValueInitExpr>(E)) {
Anders Carlsson78e83f82010-02-03 17:33:16 +0000533 EmitNullInitializationToLValue(LV, T);
Anders Carlssone78ccb42010-02-03 19:13:55 +0000534 } else if (T->isReferenceType()) {
Anders Carlsson32f36ba2010-06-26 16:35:32 +0000535 RValue RV = CGF.EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
Anders Carlssone78ccb42010-02-03 19:13:55 +0000536 CGF.EmitStoreThroughLValue(RV, LV, T);
Anders Carlsson78e83f82010-02-03 17:33:16 +0000537 } else if (T->isAnyComplexType()) {
Douglas Gregor3498bdb2009-01-29 17:44:32 +0000538 CGF.EmitComplexExprIntoAddr(E, LV.getAddress(), false);
Anders Carlsson78e83f82010-02-03 17:33:16 +0000539 } else if (CGF.hasAggregateLLVMType(T)) {
Chris Lattner1b726772010-12-02 07:07:26 +0000540 CGF.EmitAggExpr(E, AggValueSlot::forAddr(LV.getAddress(), false, true,
541 false, Dest.isZeroed()));
Eli Friedmanc8ba9612008-05-12 15:06:05 +0000542 } else {
Anders Carlsson78e83f82010-02-03 17:33:16 +0000543 CGF.EmitStoreThroughLValue(CGF.EmitAnyExpr(E), LV, T);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000544 }
Chris Lattnerf81557c2008-04-04 18:42:16 +0000545}
546
547void AggExprEmitter::EmitNullInitializationToLValue(LValue LV, QualType T) {
Chris Lattner1b726772010-12-02 07:07:26 +0000548 // If the destination slot is already zeroed out before the aggregate is
549 // copied into it, we don't have to emit any zeros here.
550 if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(T))
551 return;
552
Chris Lattnerf81557c2008-04-04 18:42:16 +0000553 if (!CGF.hasAggregateLLVMType(T)) {
554 // For non-aggregates, we can store zero
Owen Andersonc9c88b42009-07-31 20:28:54 +0000555 llvm::Value *Null = llvm::Constant::getNullValue(CGF.ConvertType(T));
Daniel Dunbar82397132008-08-06 05:32:55 +0000556 CGF.EmitStoreThroughLValue(RValue::get(Null), LV, T);
Lauro Ramos Venancio145cd892008-02-19 19:27:31 +0000557 } else {
Chris Lattnerf81557c2008-04-04 18:42:16 +0000558 // There's a potential optimization opportunity in combining
559 // memsets; that would be easy for arrays, but relatively
560 // difficult for structures with the current code.
Anders Carlsson1884eb02010-05-22 17:35:42 +0000561 CGF.EmitNullInitialization(LV.getAddress(), T);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000562 }
563}
564
Chris Lattnerf81557c2008-04-04 18:42:16 +0000565void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
Eli Friedmana385b3c2008-12-02 01:17:45 +0000566#if 0
Eli Friedman13a5be12009-12-04 01:30:56 +0000567 // FIXME: Assess perf here? Figure out what cases are worth optimizing here
568 // (Length of globals? Chunks of zeroed-out space?).
Eli Friedmana385b3c2008-12-02 01:17:45 +0000569 //
Mike Stumpf5408fe2009-05-16 07:57:57 +0000570 // If we can, prefer a copy from a global; this is a lot less code for long
571 // globals, and it's easier for the current optimizers to analyze.
Eli Friedman13a5be12009-12-04 01:30:56 +0000572 if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) {
Eli Friedman994ffef2008-11-30 02:11:09 +0000573 llvm::GlobalVariable* GV =
Eli Friedman13a5be12009-12-04 01:30:56 +0000574 new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true,
575 llvm::GlobalValue::InternalLinkage, C, "");
Daniel Dunbar79c39282010-08-21 03:15:20 +0000576 EmitFinalDestCopy(E, CGF.MakeAddrLValue(GV, E->getType()));
Eli Friedman994ffef2008-11-30 02:11:09 +0000577 return;
578 }
Eli Friedmana385b3c2008-12-02 01:17:45 +0000579#endif
Chris Lattnerd0db03a2010-09-06 00:11:41 +0000580 if (E->hadArrayRangeDesignator())
Douglas Gregora9c87802009-01-29 19:42:23 +0000581 CGF.ErrorUnsupported(E, "GNU array range designator extension");
Douglas Gregora9c87802009-01-29 19:42:23 +0000582
John McCall558d2ab2010-09-15 10:14:12 +0000583 llvm::Value *DestPtr = Dest.getAddr();
584
Chris Lattnerf81557c2008-04-04 18:42:16 +0000585 // Handle initialization of an array.
586 if (E->getType()->isArrayType()) {
587 const llvm::PointerType *APType =
588 cast<llvm::PointerType>(DestPtr->getType());
589 const llvm::ArrayType *AType =
590 cast<llvm::ArrayType>(APType->getElementType());
Mike Stump1eb44332009-09-09 15:08:12 +0000591
Chris Lattnerf81557c2008-04-04 18:42:16 +0000592 uint64_t NumInitElements = E->getNumInits();
Eli Friedman922696f2008-05-19 17:51:16 +0000593
Chris Lattner96196622008-07-26 22:37:01 +0000594 if (E->getNumInits() > 0) {
595 QualType T1 = E->getType();
596 QualType T2 = E->getInit(0)->getType();
Eli Friedman2dce5f82009-05-28 23:04:00 +0000597 if (CGF.getContext().hasSameUnqualifiedType(T1, T2)) {
Chris Lattner96196622008-07-26 22:37:01 +0000598 EmitAggLoadOfLValue(E->getInit(0));
599 return;
600 }
Eli Friedman922696f2008-05-19 17:51:16 +0000601 }
602
Chris Lattnerf81557c2008-04-04 18:42:16 +0000603 uint64_t NumArrayElements = AType->getNumElements();
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000604 QualType ElementType = CGF.getContext().getCanonicalType(E->getType());
Douglas Gregor4c678342009-01-28 21:54:33 +0000605 ElementType = CGF.getContext().getAsArrayType(ElementType)->getElementType();
Mike Stump1eb44332009-09-09 15:08:12 +0000606
John McCall0953e762009-09-24 19:53:00 +0000607 // FIXME: were we intentionally ignoring address spaces and GC attributes?
Eli Friedman1e692ac2008-06-13 23:01:12 +0000608
Chris Lattnerf81557c2008-04-04 18:42:16 +0000609 for (uint64_t i = 0; i != NumArrayElements; ++i) {
Chris Lattner1b726772010-12-02 07:07:26 +0000610 // If we're done emitting initializers and the destination is known-zeroed
611 // then we're done.
612 if (i == NumInitElements &&
613 Dest.isZeroed() &&
614 CGF.getTypes().isZeroInitializable(ElementType))
615 break;
616
Chris Lattnerf81557c2008-04-04 18:42:16 +0000617 llvm::Value *NextVal = Builder.CreateStructGEP(DestPtr, i, ".array");
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000618 LValue LV = CGF.MakeAddrLValue(NextVal, ElementType);
Chris Lattner1b726772010-12-02 07:07:26 +0000619
Chris Lattnerf81557c2008-04-04 18:42:16 +0000620 if (i < NumInitElements)
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000621 EmitInitializationToLValue(E->getInit(i), LV, ElementType);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000622 else
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000623 EmitNullInitializationToLValue(LV, ElementType);
Chris Lattner1b726772010-12-02 07:07:26 +0000624
625 // If the GEP didn't get used because of a dead zero init or something
626 // else, clean it up for -O0 builds and general tidiness.
627 if (llvm::GetElementPtrInst *GEP =
628 dyn_cast<llvm::GetElementPtrInst>(NextVal))
629 if (GEP->use_empty())
630 GEP->eraseFromParent();
Lauro Ramos Venancio145cd892008-02-19 19:27:31 +0000631 }
Chris Lattnerf81557c2008-04-04 18:42:16 +0000632 return;
633 }
Mike Stump1eb44332009-09-09 15:08:12 +0000634
Chris Lattnerf81557c2008-04-04 18:42:16 +0000635 assert(E->getType()->isRecordType() && "Only support structs/unions here!");
Mike Stump1eb44332009-09-09 15:08:12 +0000636
Chris Lattnerf81557c2008-04-04 18:42:16 +0000637 // Do struct initialization; this code just sets each individual member
638 // to the approprate value. This makes bitfield support automatic;
639 // the disadvantage is that the generated code is more difficult for
640 // the optimizer, especially with bitfields.
641 unsigned NumInitElements = E->getNumInits();
Ted Kremenek6217b802009-07-29 21:53:49 +0000642 RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
Chris Lattnerbd7de382010-09-06 00:13:11 +0000643
Douglas Gregor0bb76892009-01-29 16:53:55 +0000644 if (E->getType()->isUnionType()) {
645 // Only initialize one field of a union. The field itself is
646 // specified by the initializer list.
647 if (!E->getInitializedFieldInUnion()) {
648 // Empty union; we have nothing to do.
Mike Stump1eb44332009-09-09 15:08:12 +0000649
Douglas Gregor0bb76892009-01-29 16:53:55 +0000650#ifndef NDEBUG
651 // Make sure that it's really an empty and not a failure of
652 // semantic analysis.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000653 for (RecordDecl::field_iterator Field = SD->field_begin(),
654 FieldEnd = SD->field_end();
Douglas Gregor0bb76892009-01-29 16:53:55 +0000655 Field != FieldEnd; ++Field)
656 assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
657#endif
658 return;
659 }
660
661 // FIXME: volatility
662 FieldDecl *Field = E->getInitializedFieldInUnion();
Douglas Gregor0bb76892009-01-29 16:53:55 +0000663
Chris Lattner1b726772010-12-02 07:07:26 +0000664 LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestPtr, Field, 0);
Douglas Gregor0bb76892009-01-29 16:53:55 +0000665 if (NumInitElements) {
666 // Store the initializer into the field
Anders Carlsson78e83f82010-02-03 17:33:16 +0000667 EmitInitializationToLValue(E->getInit(0), FieldLoc, Field->getType());
Douglas Gregor0bb76892009-01-29 16:53:55 +0000668 } else {
Chris Lattner1b726772010-12-02 07:07:26 +0000669 // Default-initialize to null.
Douglas Gregor0bb76892009-01-29 16:53:55 +0000670 EmitNullInitializationToLValue(FieldLoc, Field->getType());
671 }
672
673 return;
674 }
Mike Stump1eb44332009-09-09 15:08:12 +0000675
Chris Lattnerf81557c2008-04-04 18:42:16 +0000676 // Here we iterate over the fields; this makes it simpler to both
677 // default-initialize fields and skip over unnamed fields.
Chris Lattnerbd7de382010-09-06 00:13:11 +0000678 unsigned CurInitVal = 0;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000679 for (RecordDecl::field_iterator Field = SD->field_begin(),
680 FieldEnd = SD->field_end();
Douglas Gregor44b43212008-12-11 16:49:14 +0000681 Field != FieldEnd; ++Field) {
682 // We're done once we hit the flexible array member
683 if (Field->getType()->isIncompleteArrayType())
684 break;
685
Douglas Gregor34e79462009-01-28 23:36:17 +0000686 if (Field->isUnnamedBitfield())
Chris Lattnerf81557c2008-04-04 18:42:16 +0000687 continue;
Douglas Gregor34e79462009-01-28 23:36:17 +0000688
Chris Lattner1b726772010-12-02 07:07:26 +0000689 // Don't emit GEP before a noop store of zero.
690 if (CurInitVal == NumInitElements && Dest.isZeroed() &&
691 CGF.getTypes().isZeroInitializable(E->getType()))
692 break;
693
Eli Friedman1e692ac2008-06-13 23:01:12 +0000694 // FIXME: volatility
Anders Carlssone78ccb42010-02-03 19:13:55 +0000695 LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestPtr, *Field, 0);
Fariborz Jahanian14674ff2009-05-27 19:54:11 +0000696 // We never generate write-barries for initialized fields.
Daniel Dunbarea619172010-08-21 03:22:38 +0000697 FieldLoc.setNonGC(true);
Chris Lattner1b726772010-12-02 07:07:26 +0000698
Chris Lattnerf81557c2008-04-04 18:42:16 +0000699 if (CurInitVal < NumInitElements) {
Chris Lattnerb35baae2010-03-08 21:08:07 +0000700 // Store the initializer into the field.
701 EmitInitializationToLValue(E->getInit(CurInitVal++), FieldLoc,
Anders Carlsson78e83f82010-02-03 17:33:16 +0000702 Field->getType());
Chris Lattnerf81557c2008-04-04 18:42:16 +0000703 } else {
704 // We're out of initalizers; default-initialize to null
Douglas Gregor44b43212008-12-11 16:49:14 +0000705 EmitNullInitializationToLValue(FieldLoc, Field->getType());
Chris Lattnerf81557c2008-04-04 18:42:16 +0000706 }
Chris Lattner1b726772010-12-02 07:07:26 +0000707
708 // If the GEP didn't get used because of a dead zero init or something
709 // else, clean it up for -O0 builds and general tidiness.
710 if (FieldLoc.isSimple())
711 if (llvm::GetElementPtrInst *GEP =
712 dyn_cast<llvm::GetElementPtrInst>(FieldLoc.getAddress()))
713 if (GEP->use_empty())
714 GEP->eraseFromParent();
Lauro Ramos Venancio145cd892008-02-19 19:27:31 +0000715 }
Devang Patel636c3d02007-10-26 17:44:44 +0000716}
717
Chris Lattneree755f92007-08-21 04:59:27 +0000718//===----------------------------------------------------------------------===//
719// Entry Points into this File
720//===----------------------------------------------------------------------===//
721
Chris Lattner1b726772010-12-02 07:07:26 +0000722/// GetNumNonZeroBytesInInit - Get an approximate count of the number of
723/// non-zero bytes that will be stored when outputting the initializer for the
724/// specified initializer expression.
725static uint64_t GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) {
726 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E))
727 return GetNumNonZeroBytesInInit(PE->getSubExpr(), CGF);
728
729 // 0 and 0.0 won't require any non-zero stores!
730 if (isSimpleZero(E, CGF)) return 0;
731
732 // If this is an initlist expr, sum up the size of sizes of the (present)
733 // elements. If this is something weird, assume the whole thing is non-zero.
734 const InitListExpr *ILE = dyn_cast<InitListExpr>(E);
735 if (ILE == 0 || !CGF.getTypes().isZeroInitializable(ILE->getType()))
736 return CGF.getContext().getTypeSize(E->getType())/8;
737
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000738 // InitListExprs for structs have to be handled carefully. If there are
739 // reference members, we need to consider the size of the reference, not the
740 // referencee. InitListExprs for unions and arrays can't have references.
Chris Lattner8c00ad12010-12-02 22:52:04 +0000741 if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
742 if (!RT->isUnionType()) {
743 RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
744 uint64_t NumNonZeroBytes = 0;
745
746 unsigned ILEElement = 0;
747 for (RecordDecl::field_iterator Field = SD->field_begin(),
748 FieldEnd = SD->field_end(); Field != FieldEnd; ++Field) {
749 // We're done once we hit the flexible array member or run out of
750 // InitListExpr elements.
751 if (Field->getType()->isIncompleteArrayType() ||
752 ILEElement == ILE->getNumInits())
753 break;
754 if (Field->isUnnamedBitfield())
755 continue;
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000756
Chris Lattner8c00ad12010-12-02 22:52:04 +0000757 const Expr *E = ILE->getInit(ILEElement++);
758
759 // Reference values are always non-null and have the width of a pointer.
760 if (Field->getType()->isReferenceType())
761 NumNonZeroBytes += CGF.getContext().Target.getPointerWidth(0);
762 else
763 NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF);
764 }
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000765
Chris Lattner8c00ad12010-12-02 22:52:04 +0000766 return NumNonZeroBytes;
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000767 }
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000768 }
769
770
Chris Lattner1b726772010-12-02 07:07:26 +0000771 uint64_t NumNonZeroBytes = 0;
772 for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
773 NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF);
774 return NumNonZeroBytes;
775}
776
777/// CheckAggExprForMemSetUse - If the initializer is large and has a lot of
778/// zeros in it, emit a memset and avoid storing the individual zeros.
779///
780static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,
781 CodeGenFunction &CGF) {
782 // If the slot is already known to be zeroed, nothing to do. Don't mess with
783 // volatile stores.
784 if (Slot.isZeroed() || Slot.isVolatile() || Slot.getAddr() == 0) return;
785
786 // If the type is 16-bytes or smaller, prefer individual stores over memset.
787 std::pair<uint64_t, unsigned> TypeInfo =
788 CGF.getContext().getTypeInfo(E->getType());
789 if (TypeInfo.first/8 <= 16)
790 return;
791
792 // Check to see if over 3/4 of the initializer are known to be zero. If so,
793 // we prefer to emit memset + individual stores for the rest.
794 uint64_t NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF);
795 if (NumNonZeroBytes*4 > TypeInfo.first/8)
796 return;
797
798 // Okay, it seems like a good idea to use an initial memset, emit the call.
799 llvm::Constant *SizeVal = CGF.Builder.getInt64(TypeInfo.first/8);
800 llvm::ConstantInt *AlignVal = CGF.Builder.getInt32(TypeInfo.second/8);
801
802 llvm::Value *Loc = Slot.getAddr();
803 const llvm::Type *BP = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
804
805 Loc = CGF.Builder.CreateBitCast(Loc, BP);
806 CGF.Builder.CreateCall5(CGF.CGM.getMemSetFn(Loc->getType(),
807 SizeVal->getType()),
808 Loc, CGF.Builder.getInt8(0), SizeVal, AlignVal,
809 CGF.Builder.getFalse());
810
811 // Tell the AggExprEmitter that the slot is known zero.
812 Slot.setZeroed();
813}
814
815
816
817
Mike Stumpe1129a92009-05-26 18:57:45 +0000818/// EmitAggExpr - Emit the computation of the specified expression of aggregate
819/// type. The result is computed into DestPtr. Note that if DestPtr is null,
820/// the value of the aggregate expression is not needed. If VolatileDest is
821/// true, DestPtr cannot be 0.
John McCall558d2ab2010-09-15 10:14:12 +0000822///
823/// \param IsInitializer - true if this evaluation is initializing an
824/// object whose lifetime is already being managed.
Daniel Dunbar18aba0d2010-02-05 19:38:31 +0000825//
826// FIXME: Take Qualifiers object.
John McCall558d2ab2010-09-15 10:14:12 +0000827void CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot,
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000828 bool IgnoreResult) {
Chris Lattneree755f92007-08-21 04:59:27 +0000829 assert(E && hasAggregateLLVMType(E->getType()) &&
830 "Invalid aggregate expression to emit");
Chris Lattner1b726772010-12-02 07:07:26 +0000831 assert((Slot.getAddr() != 0 || Slot.isIgnored()) &&
832 "slot has bits but no address");
Mike Stump1eb44332009-09-09 15:08:12 +0000833
Chris Lattner1b726772010-12-02 07:07:26 +0000834 // Optimize the slot if possible.
835 CheckAggExprForMemSetUse(Slot, E, *this);
836
837 AggExprEmitter(*this, Slot, IgnoreResult).Visit(const_cast<Expr*>(E));
Chris Lattneree755f92007-08-21 04:59:27 +0000838}
Daniel Dunbar7482d122008-09-09 20:49:46 +0000839
Daniel Dunbar18aba0d2010-02-05 19:38:31 +0000840LValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) {
841 assert(hasAggregateLLVMType(E->getType()) && "Invalid argument!");
Daniel Dunbar195337d2010-02-09 02:48:28 +0000842 llvm::Value *Temp = CreateMemTemp(E->getType());
Daniel Dunbar79c39282010-08-21 03:15:20 +0000843 LValue LV = MakeAddrLValue(Temp, E->getType());
Chris Lattner1b726772010-12-02 07:07:26 +0000844 EmitAggExpr(E, AggValueSlot::forAddr(Temp, LV.isVolatileQualified(), false));
Daniel Dunbar79c39282010-08-21 03:15:20 +0000845 return LV;
Daniel Dunbar18aba0d2010-02-05 19:38:31 +0000846}
847
Daniel Dunbar7482d122008-09-09 20:49:46 +0000848void CodeGenFunction::EmitAggregateCopy(llvm::Value *DestPtr,
Mike Stump27fe2e62009-05-23 22:29:41 +0000849 llvm::Value *SrcPtr, QualType Ty,
850 bool isVolatile) {
Daniel Dunbar7482d122008-09-09 20:49:46 +0000851 assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
Mike Stump1eb44332009-09-09 15:08:12 +0000852
Anders Carlsson0d7c5832010-05-03 01:20:20 +0000853 if (getContext().getLangOptions().CPlusPlus) {
854 if (const RecordType *RT = Ty->getAs<RecordType>()) {
Douglas Gregore9979482010-05-20 15:39:01 +0000855 CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
856 assert((Record->hasTrivialCopyConstructor() ||
Fariborz Jahanian1d49f212010-05-20 16:46:55 +0000857 Record->hasTrivialCopyAssignment()) &&
Douglas Gregore9979482010-05-20 15:39:01 +0000858 "Trying to aggregate-copy a type without a trivial copy "
859 "constructor or assignment operator");
Douglas Gregor419aa962010-05-20 15:48:29 +0000860 // Ignore empty classes in C++.
Douglas Gregore9979482010-05-20 15:39:01 +0000861 if (Record->isEmpty())
Anders Carlsson0d7c5832010-05-03 01:20:20 +0000862 return;
863 }
864 }
865
Chris Lattner83c96292009-02-28 18:31:01 +0000866 // Aggregate assignment turns into llvm.memcpy. This is almost valid per
Chris Lattnerca4fc2c2009-02-28 18:18:58 +0000867 // C99 6.5.16.1p3, which states "If the value being stored in an object is
868 // read from another object that overlaps in anyway the storage of the first
869 // object, then the overlap shall be exact and the two objects shall have
870 // qualified or unqualified versions of a compatible type."
871 //
Chris Lattner83c96292009-02-28 18:31:01 +0000872 // memcpy is not defined if the source and destination pointers are exactly
Chris Lattnerca4fc2c2009-02-28 18:18:58 +0000873 // equal, but other compilers do this optimization, and almost every memcpy
874 // implementation handles this case safely. If there is a libc that does not
875 // safely handle this, we can add a target hook.
Mike Stump1eb44332009-09-09 15:08:12 +0000876
Daniel Dunbar7482d122008-09-09 20:49:46 +0000877 // Get size and alignment info for this aggregate.
878 std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +0000879
Daniel Dunbar7482d122008-09-09 20:49:46 +0000880 // FIXME: Handle variable sized types.
Mike Stump1eb44332009-09-09 15:08:12 +0000881
Mike Stumpfde64202009-05-23 04:13:59 +0000882 // FIXME: If we have a volatile struct, the optimizer can remove what might
883 // appear to be `extra' memory ops:
884 //
885 // volatile struct { int i; } a, b;
886 //
887 // int main() {
888 // a = b;
889 // a = b;
890 // }
891 //
Mon P Wang3ecd7852010-04-04 03:10:52 +0000892 // we need to use a different call here. We use isVolatile to indicate when
Mike Stump49d1cd52009-05-26 22:03:21 +0000893 // either the source or the destination is volatile.
Mon P Wang3ecd7852010-04-04 03:10:52 +0000894
895 const llvm::PointerType *DPT = cast<llvm::PointerType>(DestPtr->getType());
Chris Lattner098432c2010-07-08 00:07:45 +0000896 const llvm::Type *DBP =
897 llvm::Type::getInt8PtrTy(VMContext, DPT->getAddressSpace());
898 DestPtr = Builder.CreateBitCast(DestPtr, DBP, "tmp");
Mon P Wang3ecd7852010-04-04 03:10:52 +0000899
900 const llvm::PointerType *SPT = cast<llvm::PointerType>(SrcPtr->getType());
Chris Lattner098432c2010-07-08 00:07:45 +0000901 const llvm::Type *SBP =
902 llvm::Type::getInt8PtrTy(VMContext, SPT->getAddressSpace());
903 SrcPtr = Builder.CreateBitCast(SrcPtr, SBP, "tmp");
Mon P Wang3ecd7852010-04-04 03:10:52 +0000904
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000905 if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
906 RecordDecl *Record = RecordTy->getDecl();
907 if (Record->hasObjectMember()) {
908 unsigned long size = TypeInfo.first/8;
909 const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
910 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size);
911 CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
912 SizeVal);
913 return;
914 }
915 } else if (getContext().getAsArrayType(Ty)) {
916 QualType BaseType = getContext().getBaseElementType(Ty);
917 if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
918 if (RecordTy->getDecl()->hasObjectMember()) {
919 unsigned long size = TypeInfo.first/8;
920 const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
921 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size);
922 CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
923 SizeVal);
924 return;
925 }
926 }
927 }
928
Mon P Wang3ecd7852010-04-04 03:10:52 +0000929 Builder.CreateCall5(CGM.getMemCpyFn(DestPtr->getType(), SrcPtr->getType(),
Chris Lattner77b89b82010-06-27 07:15:29 +0000930 IntPtrTy),
Daniel Dunbar7482d122008-09-09 20:49:46 +0000931 DestPtr, SrcPtr,
932 // TypeInfo.first describes size in bits.
Chris Lattner77b89b82010-06-27 07:15:29 +0000933 llvm::ConstantInt::get(IntPtrTy, TypeInfo.first/8),
Chris Lattner098432c2010-07-08 00:07:45 +0000934 Builder.getInt32(TypeInfo.second/8),
935 Builder.getInt1(isVolatile));
Daniel Dunbar7482d122008-09-09 20:49:46 +0000936}