blob: eb64996bd335693078dbd5cd43acb86fdb8aef3d [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
John McCall56ca35d2011-02-17 10:25:35 +0000119 void VisitAbstractConditionalOperator(const AbstractConditionalOperator *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);
John McCall4765fa02010-12-06 08:20:24 +0000128 void VisitExprWithCleanups(ExprWithCleanups *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
John McCalle996ffd2011-02-16 08:02:54 +0000132 void VisitOpaqueValueExpr(OpaqueValueExpr *E);
133
Eli Friedmanb1851242008-05-27 15:51:49 +0000134 void VisitVAArgExpr(VAArgExpr *E);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000135
Anders Carlsson78e83f82010-02-03 17:33:16 +0000136 void EmitInitializationToLValue(Expr *E, LValue Address, QualType T);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000137 void EmitNullInitializationToLValue(LValue Address, QualType T);
Chris Lattner9c033562007-08-21 04:25:47 +0000138 // case Expr::ChooseExprClass:
Mike Stump39406b12009-12-09 19:24:08 +0000139 void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
Chris Lattner9c033562007-08-21 04:25:47 +0000140};
141} // end anonymous namespace.
142
Chris Lattneree755f92007-08-21 04:59:27 +0000143//===----------------------------------------------------------------------===//
144// Utilities
145//===----------------------------------------------------------------------===//
Chris Lattner9c033562007-08-21 04:25:47 +0000146
Chris Lattner883f6a72007-08-11 00:04:45 +0000147/// EmitAggLoadOfLValue - Given an expression with aggregate type that
148/// represents a value lvalue, this method emits the address of the lvalue,
149/// then loads the result into DestPtr.
Chris Lattner9c033562007-08-21 04:25:47 +0000150void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
151 LValue LV = CGF.EmitLValue(E);
Mike Stump4ac20dd2009-05-23 20:28:01 +0000152 EmitFinalDestCopy(E, LV);
153}
154
John McCallfa037bd2010-05-22 22:13:32 +0000155/// \brief True if the given aggregate type requires special GC API calls.
156bool AggExprEmitter::TypeRequiresGCollection(QualType T) {
157 // Only record types have members that might require garbage collection.
158 const RecordType *RecordTy = T->getAs<RecordType>();
159 if (!RecordTy) return false;
160
161 // Don't mess with non-trivial C++ types.
162 RecordDecl *Record = RecordTy->getDecl();
163 if (isa<CXXRecordDecl>(Record) &&
164 (!cast<CXXRecordDecl>(Record)->hasTrivialCopyConstructor() ||
165 !cast<CXXRecordDecl>(Record)->hasTrivialDestructor()))
166 return false;
167
168 // Check whether the type has an object member.
169 return Record->hasObjectMember();
170}
171
172/// \brief Perform the final move to DestPtr if RequiresGCollection is set.
173///
174/// The idea is that you do something like this:
175/// RValue Result = EmitSomething(..., getReturnValueSlot());
176/// EmitGCMove(E, Result);
177/// If GC doesn't interfere, this will cause the result to be emitted
178/// directly into the return value slot. If GC does interfere, a final
179/// move will be performed.
180void AggExprEmitter::EmitGCMove(const Expr *E, RValue Src) {
John McCalld1a5f132010-09-16 03:13:23 +0000181 if (Dest.requiresGCollection()) {
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000182 std::pair<uint64_t, unsigned> TypeInfo =
183 CGF.getContext().getTypeInfo(E->getType());
184 unsigned long size = TypeInfo.first/8;
185 const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
186 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size);
John McCall558d2ab2010-09-15 10:14:12 +0000187 CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF, Dest.getAddr(),
John McCallfa037bd2010-05-22 22:13:32 +0000188 Src.getAggregateAddr(),
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000189 SizeVal);
190 }
John McCallfa037bd2010-05-22 22:13:32 +0000191}
192
Mike Stump4ac20dd2009-05-23 20:28:01 +0000193/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
Mike Stump49d1cd52009-05-26 22:03:21 +0000194void AggExprEmitter::EmitFinalDestCopy(const Expr *E, RValue Src, bool Ignore) {
Mike Stump4ac20dd2009-05-23 20:28:01 +0000195 assert(Src.isAggregate() && "value must be aggregate value!");
196
John McCall558d2ab2010-09-15 10:14:12 +0000197 // If Dest is ignored, then we're evaluating an aggregate expression
John McCalla8f28da2010-08-25 02:50:31 +0000198 // in a context (like an expression statement) that doesn't care
199 // about the result. C says that an lvalue-to-rvalue conversion is
200 // performed in these cases; C++ says that it is not. In either
201 // case, we don't actually need to do anything unless the value is
202 // volatile.
John McCall558d2ab2010-09-15 10:14:12 +0000203 if (Dest.isIgnored()) {
John McCalla8f28da2010-08-25 02:50:31 +0000204 if (!Src.isVolatileQualified() ||
205 CGF.CGM.getLangOptions().CPlusPlus ||
206 (IgnoreResult && Ignore))
Mike Stump9ccb1032009-05-23 22:01:27 +0000207 return;
Fariborz Jahanian8a970052010-10-22 22:05:03 +0000208
Mike Stump49d1cd52009-05-26 22:03:21 +0000209 // If the source is volatile, we must read from it; to do that, we need
210 // some place to put it.
John McCall558d2ab2010-09-15 10:14:12 +0000211 Dest = CGF.CreateAggTemp(E->getType(), "agg.tmp");
Mike Stump9ccb1032009-05-23 22:01:27 +0000212 }
Chris Lattner883f6a72007-08-11 00:04:45 +0000213
John McCalld1a5f132010-09-16 03:13:23 +0000214 if (Dest.requiresGCollection()) {
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000215 std::pair<uint64_t, unsigned> TypeInfo =
216 CGF.getContext().getTypeInfo(E->getType());
217 unsigned long size = TypeInfo.first/8;
218 const llvm::Type *SizeTy = CGF.ConvertType(CGF.getContext().getSizeType());
219 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size);
Fariborz Jahanian08c32132009-08-31 19:33:16 +0000220 CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF,
John McCall558d2ab2010-09-15 10:14:12 +0000221 Dest.getAddr(),
222 Src.getAggregateAddr(),
223 SizeVal);
Fariborz Jahanian08c32132009-08-31 19:33:16 +0000224 return;
225 }
Mike Stump4ac20dd2009-05-23 20:28:01 +0000226 // If the result of the assignment is used, copy the LHS there also.
227 // FIXME: Pass VolatileDest as well. I think we also need to merge volatile
228 // from the source as well, as we can't eliminate it if either operand
229 // is volatile, unless copy has volatile for both source and destination..
John McCall558d2ab2010-09-15 10:14:12 +0000230 CGF.EmitAggregateCopy(Dest.getAddr(), Src.getAggregateAddr(), E->getType(),
231 Dest.isVolatile()|Src.isVolatileQualified());
Mike Stump4ac20dd2009-05-23 20:28:01 +0000232}
233
234/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.
Mike Stump49d1cd52009-05-26 22:03:21 +0000235void AggExprEmitter::EmitFinalDestCopy(const Expr *E, LValue Src, bool Ignore) {
Mike Stump4ac20dd2009-05-23 20:28:01 +0000236 assert(Src.isSimple() && "Can't have aggregate bitfield, vector, etc");
237
238 EmitFinalDestCopy(E, RValue::getAggregate(Src.getAddress(),
Mike Stump49d1cd52009-05-26 22:03:21 +0000239 Src.isVolatileQualified()),
240 Ignore);
Chris Lattner883f6a72007-08-11 00:04:45 +0000241}
242
Chris Lattneree755f92007-08-21 04:59:27 +0000243//===----------------------------------------------------------------------===//
244// Visitor Methods
245//===----------------------------------------------------------------------===//
246
John McCalle996ffd2011-02-16 08:02:54 +0000247void AggExprEmitter::VisitOpaqueValueExpr(OpaqueValueExpr *e) {
John McCall56ca35d2011-02-17 10:25:35 +0000248 EmitFinalDestCopy(e, CGF.getOpaqueLValueMapping(e));
John McCalle996ffd2011-02-16 08:02:54 +0000249}
250
Anders Carlsson4d8673b2009-08-07 23:22:37 +0000251void AggExprEmitter::VisitCastExpr(CastExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000252 if (Dest.isIgnored() && E->getCastKind() != CK_Dynamic) {
Douglas Gregor4ce46c22010-03-07 23:24:59 +0000253 Visit(E->getSubExpr());
254 return;
255 }
256
Anders Carlsson30168422009-09-29 01:23:39 +0000257 switch (E->getCastKind()) {
John McCall2de56d12010-08-25 11:45:40 +0000258 case CK_Dynamic: {
Douglas Gregor69cfeb12010-05-14 21:31:02 +0000259 assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?");
260 LValue LV = CGF.EmitCheckedLValue(E->getSubExpr());
261 // FIXME: Do we also need to handle property references here?
262 if (LV.isSimple())
263 CGF.EmitDynamicCast(LV.getAddress(), cast<CXXDynamicCastExpr>(E));
264 else
265 CGF.CGM.ErrorUnsupported(E, "non-simple lvalue dynamic_cast");
266
John McCall558d2ab2010-09-15 10:14:12 +0000267 if (!Dest.isIgnored())
268 CGF.CGM.ErrorUnsupported(E, "lvalue dynamic_cast with a destination");
Douglas Gregor69cfeb12010-05-14 21:31:02 +0000269 break;
270 }
271
John McCall2de56d12010-08-25 11:45:40 +0000272 case CK_ToUnion: {
Anders Carlsson4d8673b2009-08-07 23:22:37 +0000273 // GCC union extension
Daniel Dunbar79c39282010-08-21 03:15:20 +0000274 QualType Ty = E->getSubExpr()->getType();
275 QualType PtrTy = CGF.getContext().getPointerType(Ty);
John McCall558d2ab2010-09-15 10:14:12 +0000276 llvm::Value *CastPtr = Builder.CreateBitCast(Dest.getAddr(),
Eli Friedman34ebf4d2009-06-03 20:45:06 +0000277 CGF.ConvertType(PtrTy));
Daniel Dunbar79c39282010-08-21 03:15:20 +0000278 EmitInitializationToLValue(E->getSubExpr(), CGF.MakeAddrLValue(CastPtr, Ty),
279 Ty);
Anders Carlsson30168422009-09-29 01:23:39 +0000280 break;
Nuno Lopes7e916272009-01-15 20:14:33 +0000281 }
Mike Stump1eb44332009-09-09 15:08:12 +0000282
John McCall2de56d12010-08-25 11:45:40 +0000283 case CK_DerivedToBase:
284 case CK_BaseToDerived:
285 case CK_UncheckedDerivedToBase: {
Douglas Gregor2d6b0e92010-05-22 05:17:18 +0000286 assert(0 && "cannot perform hierarchy conversion in EmitAggExpr: "
287 "should have been unpacked before we got here");
288 break;
289 }
290
John McCallf6a16482010-12-04 03:47:34 +0000291 case CK_GetObjCProperty: {
292 LValue LV = CGF.EmitLValue(E->getSubExpr());
293 assert(LV.isPropertyRef());
294 RValue RV = CGF.EmitLoadOfPropertyRefLValue(LV, getReturnValueSlot());
295 EmitGCMove(E, RV);
296 break;
297 }
298
299 case CK_LValueToRValue: // hope for downstream optimization
John McCall2de56d12010-08-25 11:45:40 +0000300 case CK_NoOp:
301 case CK_UserDefinedConversion:
302 case CK_ConstructorConversion:
Anders Carlsson30168422009-09-29 01:23:39 +0000303 assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(),
304 E->getType()) &&
305 "Implicit cast types must be compatible");
306 Visit(E->getSubExpr());
307 break;
John McCall0ae287a2010-12-01 04:43:34 +0000308
John McCall2de56d12010-08-25 11:45:40 +0000309 case CK_LValueBitCast:
John McCall0ae287a2010-12-01 04:43:34 +0000310 llvm_unreachable("should not be emitting lvalue bitcast as rvalue");
Douglas Gregore39a3892010-07-13 23:17:26 +0000311 break;
John McCall0ae287a2010-12-01 04:43:34 +0000312
313 case CK_Dependent:
314 case CK_BitCast:
315 case CK_ArrayToPointerDecay:
316 case CK_FunctionToPointerDecay:
317 case CK_NullToPointer:
318 case CK_NullToMemberPointer:
319 case CK_BaseToDerivedMemberPointer:
320 case CK_DerivedToBaseMemberPointer:
321 case CK_MemberPointerToBoolean:
322 case CK_IntegralToPointer:
323 case CK_PointerToIntegral:
324 case CK_PointerToBoolean:
325 case CK_ToVoid:
326 case CK_VectorSplat:
327 case CK_IntegralCast:
328 case CK_IntegralToBoolean:
329 case CK_IntegralToFloating:
330 case CK_FloatingToIntegral:
331 case CK_FloatingToBoolean:
332 case CK_FloatingCast:
333 case CK_AnyPointerToObjCPointerCast:
334 case CK_AnyPointerToBlockPointerCast:
335 case CK_ObjCObjectLValueCast:
336 case CK_FloatingRealToComplex:
337 case CK_FloatingComplexToReal:
338 case CK_FloatingComplexToBoolean:
339 case CK_FloatingComplexCast:
340 case CK_FloatingComplexToIntegralComplex:
341 case CK_IntegralRealToComplex:
342 case CK_IntegralComplexToReal:
343 case CK_IntegralComplexToBoolean:
344 case CK_IntegralComplexCast:
345 case CK_IntegralComplexToFloatingComplex:
346 llvm_unreachable("cast kind invalid for aggregate types");
Anders Carlsson30168422009-09-29 01:23:39 +0000347 }
Anders Carlssone4707ff2008-01-14 06:28:57 +0000348}
349
Chris Lattner96196622008-07-26 22:37:01 +0000350void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
Anders Carlssone70e8f72009-05-27 16:45:02 +0000351 if (E->getCallReturnType()->isReferenceType()) {
352 EmitAggLoadOfLValue(E);
353 return;
354 }
Mike Stump1eb44332009-09-09 15:08:12 +0000355
John McCallfa037bd2010-05-22 22:13:32 +0000356 RValue RV = CGF.EmitCallExpr(E, getReturnValueSlot());
357 EmitGCMove(E, RV);
Anders Carlsson148fe672007-10-31 22:04:46 +0000358}
Chris Lattner96196622008-07-26 22:37:01 +0000359
360void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
John McCallfa037bd2010-05-22 22:13:32 +0000361 RValue RV = CGF.EmitObjCMessageExpr(E, getReturnValueSlot());
362 EmitGCMove(E, RV);
Chris Lattner8fdf3282008-06-24 17:04:18 +0000363}
Anders Carlsson148fe672007-10-31 22:04:46 +0000364
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000365void AggExprEmitter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
John McCallf6a16482010-12-04 03:47:34 +0000366 llvm_unreachable("direct property access not surrounded by "
367 "lvalue-to-rvalue cast");
Daniel Dunbar9c3fc702008-08-27 06:57:25 +0000368}
369
Chris Lattner96196622008-07-26 22:37:01 +0000370void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
John McCall2a416372010-12-05 02:00:02 +0000371 CGF.EmitIgnoredExpr(E->getLHS());
John McCall558d2ab2010-09-15 10:14:12 +0000372 Visit(E->getRHS());
Eli Friedman07fa52a2008-05-20 07:56:31 +0000373}
374
Chris Lattnerb2d963f2007-08-31 22:54:14 +0000375void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
John McCall150b4622011-01-26 04:00:11 +0000376 CodeGenFunction::StmtExprEvaluation eval(CGF);
John McCall558d2ab2010-09-15 10:14:12 +0000377 CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest);
Chris Lattnerb2d963f2007-08-31 22:54:14 +0000378}
379
Chris Lattner9c033562007-08-21 04:25:47 +0000380void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
John McCall2de56d12010-08-25 11:45:40 +0000381 if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI)
Fariborz Jahanian8bfd31f2009-10-22 22:57:31 +0000382 VisitPointerToDataMemberBinaryOperator(E);
383 else
384 CGF.ErrorUnsupported(E, "aggregate binary expression");
385}
386
387void AggExprEmitter::VisitPointerToDataMemberBinaryOperator(
388 const BinaryOperator *E) {
389 LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E);
390 EmitFinalDestCopy(E, LV);
Chris Lattneree755f92007-08-21 04:59:27 +0000391}
392
Chris Lattner03d6fb92007-08-21 04:43:17 +0000393void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
Eli Friedmanff6e2b72008-02-11 01:09:17 +0000394 // For an assignment to work, the value on the right has
395 // to be compatible with the value on the left.
Eli Friedman2dce5f82009-05-28 23:04:00 +0000396 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
397 E->getRHS()->getType())
Eli Friedmanff6e2b72008-02-11 01:09:17 +0000398 && "Invalid assignment");
John McCallcd940a12010-12-06 06:10:02 +0000399
400 // FIXME: __block variables need the RHS evaluated first!
Chris Lattner9c033562007-08-21 04:25:47 +0000401 LValue LHS = CGF.EmitLValue(E->getLHS());
Chris Lattner883f6a72007-08-11 00:04:45 +0000402
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000403 // We have to special case property setters, otherwise we must have
404 // a simple lvalue (no aggregates inside vectors, bitfields).
405 if (LHS.isPropertyRef()) {
Fariborz Jahanian68af13f2011-03-30 16:11:20 +0000406 const ObjCPropertyRefExpr *RE = LHS.getPropertyRefExpr();
407 QualType ArgType = RE->getSetterArgType();
408 RValue Src;
409 if (ArgType->isReferenceType())
410 Src = CGF.EmitReferenceBindingToExpr(E->getRHS(), 0);
411 else {
412 AggValueSlot Slot = EnsureSlot(E->getRHS()->getType());
413 CGF.EmitAggExpr(E->getRHS(), Slot);
414 Src = Slot.asRValue();
415 }
416 CGF.EmitStoreThroughPropertyRefLValue(Src, LHS);
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000417 } else {
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000418 bool GCollection = false;
John McCallfa037bd2010-05-22 22:13:32 +0000419 if (CGF.getContext().getLangOptions().getGCMode())
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000420 GCollection = TypeRequiresGCollection(E->getLHS()->getType());
John McCallfa037bd2010-05-22 22:13:32 +0000421
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000422 // Codegen the RHS so that it stores directly into the LHS.
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000423 AggValueSlot LHSSlot = AggValueSlot::forLValue(LHS, true,
424 GCollection);
425 CGF.EmitAggExpr(E->getRHS(), LHSSlot, false);
Mike Stump49d1cd52009-05-26 22:03:21 +0000426 EmitFinalDestCopy(E, LHS, true);
Daniel Dunbar7f8ea5c2008-08-30 05:35:15 +0000427 }
Chris Lattner883f6a72007-08-11 00:04:45 +0000428}
429
John McCall56ca35d2011-02-17 10:25:35 +0000430void AggExprEmitter::
431VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
Daniel Dunbar9615ecb2008-11-13 01:38:36 +0000432 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
433 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
434 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
Mike Stump1eb44332009-09-09 15:08:12 +0000435
John McCall56ca35d2011-02-17 10:25:35 +0000436 // Bind the common expression if necessary.
437 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
438
John McCall150b4622011-01-26 04:00:11 +0000439 CodeGenFunction::ConditionalEvaluation eval(CGF);
Eli Friedman8e274bd2009-12-25 06:17:05 +0000440 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000441
John McCall74fb0ed2010-11-17 00:07:33 +0000442 // Save whether the destination's lifetime is externally managed.
443 bool DestLifetimeManaged = Dest.isLifetimeExternallyManaged();
Chris Lattner883f6a72007-08-11 00:04:45 +0000444
John McCall150b4622011-01-26 04:00:11 +0000445 eval.begin(CGF);
446 CGF.EmitBlock(LHSBlock);
John McCall56ca35d2011-02-17 10:25:35 +0000447 Visit(E->getTrueExpr());
John McCall150b4622011-01-26 04:00:11 +0000448 eval.end(CGF);
Mike Stump1eb44332009-09-09 15:08:12 +0000449
John McCall150b4622011-01-26 04:00:11 +0000450 assert(CGF.HaveInsertPoint() && "expression evaluation ended with no IP!");
451 CGF.Builder.CreateBr(ContBlock);
Mike Stump1eb44332009-09-09 15:08:12 +0000452
John McCall74fb0ed2010-11-17 00:07:33 +0000453 // If the result of an agg expression is unused, then the emission
454 // of the LHS might need to create a destination slot. That's fine
455 // with us, and we can safely emit the RHS into the same slot, but
456 // we shouldn't claim that its lifetime is externally managed.
457 Dest.setLifetimeExternallyManaged(DestLifetimeManaged);
458
John McCall150b4622011-01-26 04:00:11 +0000459 eval.begin(CGF);
460 CGF.EmitBlock(RHSBlock);
John McCall56ca35d2011-02-17 10:25:35 +0000461 Visit(E->getFalseExpr());
John McCall150b4622011-01-26 04:00:11 +0000462 eval.end(CGF);
Mike Stump1eb44332009-09-09 15:08:12 +0000463
Chris Lattner9c033562007-08-21 04:25:47 +0000464 CGF.EmitBlock(ContBlock);
Chris Lattner883f6a72007-08-11 00:04:45 +0000465}
Chris Lattneree755f92007-08-21 04:59:27 +0000466
Anders Carlssona294ca82009-07-08 18:33:14 +0000467void AggExprEmitter::VisitChooseExpr(const ChooseExpr *CE) {
468 Visit(CE->getChosenSubExpr(CGF.getContext()));
469}
470
Eli Friedmanb1851242008-05-27 15:51:49 +0000471void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
Daniel Dunbar07855702009-02-11 22:25:55 +0000472 llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr());
Anders Carlssonddf7cac2008-11-04 05:30:00 +0000473 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType());
474
Sebastian Redl0262f022009-01-09 21:09:38 +0000475 if (!ArgPtr) {
Anders Carlssonddf7cac2008-11-04 05:30:00 +0000476 CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
Sebastian Redl0262f022009-01-09 21:09:38 +0000477 return;
478 }
479
Daniel Dunbar79c39282010-08-21 03:15:20 +0000480 EmitFinalDestCopy(VE, CGF.MakeAddrLValue(ArgPtr, VE->getType()));
Eli Friedmanb1851242008-05-27 15:51:49 +0000481}
482
Anders Carlssonb58d0172009-05-30 23:23:33 +0000483void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000484 // Ensure that we have a slot, but if we already do, remember
485 // whether its lifetime was externally managed.
486 bool WasManaged = Dest.isLifetimeExternallyManaged();
487 Dest = EnsureSlot(E->getType());
488 Dest.setLifetimeExternallyManaged();
Mike Stump1eb44332009-09-09 15:08:12 +0000489
John McCall558d2ab2010-09-15 10:14:12 +0000490 Visit(E->getSubExpr());
Anders Carlssonb58d0172009-05-30 23:23:33 +0000491
John McCall558d2ab2010-09-15 10:14:12 +0000492 // Set up the temporary's destructor if its lifetime wasn't already
493 // being managed.
494 if (!WasManaged)
495 CGF.EmitCXXTemporary(E->getTemporary(), Dest.getAddr());
Anders Carlssonb58d0172009-05-30 23:23:33 +0000496}
497
Anders Carlssonb14095a2009-04-17 00:06:03 +0000498void
Anders Carlsson31ccf372009-05-03 17:47:16 +0000499AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000500 AggValueSlot Slot = EnsureSlot(E->getType());
501 CGF.EmitCXXConstructExpr(E, Slot);
Anders Carlsson7f6ad152009-05-19 04:48:36 +0000502}
503
John McCall4765fa02010-12-06 08:20:24 +0000504void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
505 CGF.EmitExprWithCleanups(E, Dest);
Anders Carlssonb14095a2009-04-17 00:06:03 +0000506}
507
Douglas Gregored8abf12010-07-08 06:14:04 +0000508void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000509 QualType T = E->getType();
510 AggValueSlot Slot = EnsureSlot(T);
511 EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T), T);
Anders Carlsson30311fa2009-12-16 06:57:54 +0000512}
513
514void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
John McCall558d2ab2010-09-15 10:14:12 +0000515 QualType T = E->getType();
516 AggValueSlot Slot = EnsureSlot(T);
517 EmitNullInitializationToLValue(CGF.MakeAddrLValue(Slot.getAddr(), T), T);
Nuno Lopes329763b2009-10-18 15:18:11 +0000518}
519
Chris Lattner1b726772010-12-02 07:07:26 +0000520/// isSimpleZero - If emitting this value will obviously just cause a store of
521/// zero to memory, return true. This can return false if uncertain, so it just
522/// handles simple cases.
523static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {
524 // (0)
525 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E))
526 return isSimpleZero(PE->getSubExpr(), CGF);
527 // 0
528 if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
529 return IL->getValue() == 0;
530 // +0.0
531 if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E))
532 return FL->getValue().isPosZero();
533 // int()
534 if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) &&
535 CGF.getTypes().isZeroInitializable(E->getType()))
536 return true;
537 // (int*)0 - Null pointer expressions.
538 if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
539 return ICE->getCastKind() == CK_NullToPointer;
540 // '\0'
541 if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E))
542 return CL->getValue() == 0;
543
544 // Otherwise, hard case: conservatively return false.
545 return false;
546}
547
548
Anders Carlsson78e83f82010-02-03 17:33:16 +0000549void
550AggExprEmitter::EmitInitializationToLValue(Expr* E, LValue LV, QualType T) {
Mike Stump7f79f9b2009-05-29 15:46:01 +0000551 // FIXME: Ignore result?
Chris Lattnerf81557c2008-04-04 18:42:16 +0000552 // FIXME: Are initializers affected by volatile?
Chris Lattner1b726772010-12-02 07:07:26 +0000553 if (Dest.isZeroed() && isSimpleZero(E, CGF)) {
554 // Storing "i32 0" to a zero'd memory location is a noop.
555 } else if (isa<ImplicitValueInitExpr>(E)) {
Anders Carlsson78e83f82010-02-03 17:33:16 +0000556 EmitNullInitializationToLValue(LV, T);
Anders Carlssone78ccb42010-02-03 19:13:55 +0000557 } else if (T->isReferenceType()) {
Anders Carlsson32f36ba2010-06-26 16:35:32 +0000558 RValue RV = CGF.EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
Anders Carlssone78ccb42010-02-03 19:13:55 +0000559 CGF.EmitStoreThroughLValue(RV, LV, T);
Anders Carlsson78e83f82010-02-03 17:33:16 +0000560 } else if (T->isAnyComplexType()) {
Douglas Gregor3498bdb2009-01-29 17:44:32 +0000561 CGF.EmitComplexExprIntoAddr(E, LV.getAddress(), false);
Anders Carlsson78e83f82010-02-03 17:33:16 +0000562 } else if (CGF.hasAggregateLLVMType(T)) {
Chris Lattner1b726772010-12-02 07:07:26 +0000563 CGF.EmitAggExpr(E, AggValueSlot::forAddr(LV.getAddress(), false, true,
564 false, Dest.isZeroed()));
Eli Friedmanc8ba9612008-05-12 15:06:05 +0000565 } else {
John McCall2a416372010-12-05 02:00:02 +0000566 CGF.EmitStoreThroughLValue(RValue::get(CGF.EmitScalarExpr(E)), LV, T);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000567 }
Chris Lattnerf81557c2008-04-04 18:42:16 +0000568}
569
570void AggExprEmitter::EmitNullInitializationToLValue(LValue LV, QualType T) {
Chris Lattner1b726772010-12-02 07:07:26 +0000571 // If the destination slot is already zeroed out before the aggregate is
572 // copied into it, we don't have to emit any zeros here.
573 if (Dest.isZeroed() && CGF.getTypes().isZeroInitializable(T))
574 return;
575
Chris Lattnerf81557c2008-04-04 18:42:16 +0000576 if (!CGF.hasAggregateLLVMType(T)) {
577 // For non-aggregates, we can store zero
Owen Andersonc9c88b42009-07-31 20:28:54 +0000578 llvm::Value *Null = llvm::Constant::getNullValue(CGF.ConvertType(T));
Daniel Dunbar82397132008-08-06 05:32:55 +0000579 CGF.EmitStoreThroughLValue(RValue::get(Null), LV, T);
Lauro Ramos Venancio145cd892008-02-19 19:27:31 +0000580 } else {
Chris Lattnerf81557c2008-04-04 18:42:16 +0000581 // There's a potential optimization opportunity in combining
582 // memsets; that would be easy for arrays, but relatively
583 // difficult for structures with the current code.
Anders Carlsson1884eb02010-05-22 17:35:42 +0000584 CGF.EmitNullInitialization(LV.getAddress(), T);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000585 }
586}
587
Chris Lattnerf81557c2008-04-04 18:42:16 +0000588void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
Eli Friedmana385b3c2008-12-02 01:17:45 +0000589#if 0
Eli Friedman13a5be12009-12-04 01:30:56 +0000590 // FIXME: Assess perf here? Figure out what cases are worth optimizing here
591 // (Length of globals? Chunks of zeroed-out space?).
Eli Friedmana385b3c2008-12-02 01:17:45 +0000592 //
Mike Stumpf5408fe2009-05-16 07:57:57 +0000593 // If we can, prefer a copy from a global; this is a lot less code for long
594 // globals, and it's easier for the current optimizers to analyze.
Eli Friedman13a5be12009-12-04 01:30:56 +0000595 if (llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, E->getType(), &CGF)) {
Eli Friedman994ffef2008-11-30 02:11:09 +0000596 llvm::GlobalVariable* GV =
Eli Friedman13a5be12009-12-04 01:30:56 +0000597 new llvm::GlobalVariable(CGF.CGM.getModule(), C->getType(), true,
598 llvm::GlobalValue::InternalLinkage, C, "");
Daniel Dunbar79c39282010-08-21 03:15:20 +0000599 EmitFinalDestCopy(E, CGF.MakeAddrLValue(GV, E->getType()));
Eli Friedman994ffef2008-11-30 02:11:09 +0000600 return;
601 }
Eli Friedmana385b3c2008-12-02 01:17:45 +0000602#endif
Chris Lattnerd0db03a2010-09-06 00:11:41 +0000603 if (E->hadArrayRangeDesignator())
Douglas Gregora9c87802009-01-29 19:42:23 +0000604 CGF.ErrorUnsupported(E, "GNU array range designator extension");
Douglas Gregora9c87802009-01-29 19:42:23 +0000605
John McCall558d2ab2010-09-15 10:14:12 +0000606 llvm::Value *DestPtr = Dest.getAddr();
607
Chris Lattnerf81557c2008-04-04 18:42:16 +0000608 // Handle initialization of an array.
609 if (E->getType()->isArrayType()) {
610 const llvm::PointerType *APType =
611 cast<llvm::PointerType>(DestPtr->getType());
612 const llvm::ArrayType *AType =
613 cast<llvm::ArrayType>(APType->getElementType());
Mike Stump1eb44332009-09-09 15:08:12 +0000614
Chris Lattnerf81557c2008-04-04 18:42:16 +0000615 uint64_t NumInitElements = E->getNumInits();
Eli Friedman922696f2008-05-19 17:51:16 +0000616
Chris Lattner96196622008-07-26 22:37:01 +0000617 if (E->getNumInits() > 0) {
618 QualType T1 = E->getType();
619 QualType T2 = E->getInit(0)->getType();
Eli Friedman2dce5f82009-05-28 23:04:00 +0000620 if (CGF.getContext().hasSameUnqualifiedType(T1, T2)) {
Chris Lattner96196622008-07-26 22:37:01 +0000621 EmitAggLoadOfLValue(E->getInit(0));
622 return;
623 }
Eli Friedman922696f2008-05-19 17:51:16 +0000624 }
625
Chris Lattnerf81557c2008-04-04 18:42:16 +0000626 uint64_t NumArrayElements = AType->getNumElements();
Chris Lattnerc63a1f22008-08-04 07:31:14 +0000627 QualType ElementType = CGF.getContext().getCanonicalType(E->getType());
Douglas Gregor4c678342009-01-28 21:54:33 +0000628 ElementType = CGF.getContext().getAsArrayType(ElementType)->getElementType();
Mike Stump1eb44332009-09-09 15:08:12 +0000629
John McCall0953e762009-09-24 19:53:00 +0000630 // FIXME: were we intentionally ignoring address spaces and GC attributes?
Eli Friedman1e692ac2008-06-13 23:01:12 +0000631
Chris Lattnerf81557c2008-04-04 18:42:16 +0000632 for (uint64_t i = 0; i != NumArrayElements; ++i) {
Chris Lattner1b726772010-12-02 07:07:26 +0000633 // If we're done emitting initializers and the destination is known-zeroed
634 // then we're done.
635 if (i == NumInitElements &&
636 Dest.isZeroed() &&
637 CGF.getTypes().isZeroInitializable(ElementType))
638 break;
639
Chris Lattnerf81557c2008-04-04 18:42:16 +0000640 llvm::Value *NextVal = Builder.CreateStructGEP(DestPtr, i, ".array");
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000641 LValue LV = CGF.MakeAddrLValue(NextVal, ElementType);
Chris Lattner1b726772010-12-02 07:07:26 +0000642
Chris Lattnerf81557c2008-04-04 18:42:16 +0000643 if (i < NumInitElements)
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000644 EmitInitializationToLValue(E->getInit(i), LV, ElementType);
Chris Lattnerf81557c2008-04-04 18:42:16 +0000645 else
Daniel Dunbar9f553f52010-08-21 03:08:16 +0000646 EmitNullInitializationToLValue(LV, ElementType);
Chris Lattner1b726772010-12-02 07:07:26 +0000647
648 // If the GEP didn't get used because of a dead zero init or something
649 // else, clean it up for -O0 builds and general tidiness.
650 if (llvm::GetElementPtrInst *GEP =
651 dyn_cast<llvm::GetElementPtrInst>(NextVal))
652 if (GEP->use_empty())
653 GEP->eraseFromParent();
Lauro Ramos Venancio145cd892008-02-19 19:27:31 +0000654 }
Chris Lattnerf81557c2008-04-04 18:42:16 +0000655 return;
656 }
Mike Stump1eb44332009-09-09 15:08:12 +0000657
Chris Lattnerf81557c2008-04-04 18:42:16 +0000658 assert(E->getType()->isRecordType() && "Only support structs/unions here!");
Mike Stump1eb44332009-09-09 15:08:12 +0000659
Chris Lattnerf81557c2008-04-04 18:42:16 +0000660 // Do struct initialization; this code just sets each individual member
661 // to the approprate value. This makes bitfield support automatic;
662 // the disadvantage is that the generated code is more difficult for
663 // the optimizer, especially with bitfields.
664 unsigned NumInitElements = E->getNumInits();
Ted Kremenek6217b802009-07-29 21:53:49 +0000665 RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
Chris Lattnerbd7de382010-09-06 00:13:11 +0000666
Douglas Gregor0bb76892009-01-29 16:53:55 +0000667 if (E->getType()->isUnionType()) {
668 // Only initialize one field of a union. The field itself is
669 // specified by the initializer list.
670 if (!E->getInitializedFieldInUnion()) {
671 // Empty union; we have nothing to do.
Mike Stump1eb44332009-09-09 15:08:12 +0000672
Douglas Gregor0bb76892009-01-29 16:53:55 +0000673#ifndef NDEBUG
674 // Make sure that it's really an empty and not a failure of
675 // semantic analysis.
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000676 for (RecordDecl::field_iterator Field = SD->field_begin(),
677 FieldEnd = SD->field_end();
Douglas Gregor0bb76892009-01-29 16:53:55 +0000678 Field != FieldEnd; ++Field)
679 assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
680#endif
681 return;
682 }
683
684 // FIXME: volatility
685 FieldDecl *Field = E->getInitializedFieldInUnion();
Douglas Gregor0bb76892009-01-29 16:53:55 +0000686
Chris Lattner1b726772010-12-02 07:07:26 +0000687 LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestPtr, Field, 0);
Douglas Gregor0bb76892009-01-29 16:53:55 +0000688 if (NumInitElements) {
689 // Store the initializer into the field
Anders Carlsson78e83f82010-02-03 17:33:16 +0000690 EmitInitializationToLValue(E->getInit(0), FieldLoc, Field->getType());
Douglas Gregor0bb76892009-01-29 16:53:55 +0000691 } else {
Chris Lattner1b726772010-12-02 07:07:26 +0000692 // Default-initialize to null.
Douglas Gregor0bb76892009-01-29 16:53:55 +0000693 EmitNullInitializationToLValue(FieldLoc, Field->getType());
694 }
695
696 return;
697 }
Mike Stump1eb44332009-09-09 15:08:12 +0000698
Chris Lattnerf81557c2008-04-04 18:42:16 +0000699 // Here we iterate over the fields; this makes it simpler to both
700 // default-initialize fields and skip over unnamed fields.
Chris Lattnerbd7de382010-09-06 00:13:11 +0000701 unsigned CurInitVal = 0;
Argyrios Kyrtzidis17945a02009-06-30 02:36:12 +0000702 for (RecordDecl::field_iterator Field = SD->field_begin(),
703 FieldEnd = SD->field_end();
Douglas Gregor44b43212008-12-11 16:49:14 +0000704 Field != FieldEnd; ++Field) {
705 // We're done once we hit the flexible array member
706 if (Field->getType()->isIncompleteArrayType())
707 break;
708
Douglas Gregor34e79462009-01-28 23:36:17 +0000709 if (Field->isUnnamedBitfield())
Chris Lattnerf81557c2008-04-04 18:42:16 +0000710 continue;
Douglas Gregor34e79462009-01-28 23:36:17 +0000711
Chris Lattner1b726772010-12-02 07:07:26 +0000712 // Don't emit GEP before a noop store of zero.
713 if (CurInitVal == NumInitElements && Dest.isZeroed() &&
714 CGF.getTypes().isZeroInitializable(E->getType()))
715 break;
716
Eli Friedman1e692ac2008-06-13 23:01:12 +0000717 // FIXME: volatility
Anders Carlssone78ccb42010-02-03 19:13:55 +0000718 LValue FieldLoc = CGF.EmitLValueForFieldInitialization(DestPtr, *Field, 0);
Fariborz Jahanian14674ff2009-05-27 19:54:11 +0000719 // We never generate write-barries for initialized fields.
Daniel Dunbarea619172010-08-21 03:22:38 +0000720 FieldLoc.setNonGC(true);
Chris Lattner1b726772010-12-02 07:07:26 +0000721
Chris Lattnerf81557c2008-04-04 18:42:16 +0000722 if (CurInitVal < NumInitElements) {
Chris Lattnerb35baae2010-03-08 21:08:07 +0000723 // Store the initializer into the field.
724 EmitInitializationToLValue(E->getInit(CurInitVal++), FieldLoc,
Anders Carlsson78e83f82010-02-03 17:33:16 +0000725 Field->getType());
Chris Lattnerf81557c2008-04-04 18:42:16 +0000726 } else {
727 // We're out of initalizers; default-initialize to null
Douglas Gregor44b43212008-12-11 16:49:14 +0000728 EmitNullInitializationToLValue(FieldLoc, Field->getType());
Chris Lattnerf81557c2008-04-04 18:42:16 +0000729 }
Chris Lattner1b726772010-12-02 07:07:26 +0000730
731 // If the GEP didn't get used because of a dead zero init or something
732 // else, clean it up for -O0 builds and general tidiness.
733 if (FieldLoc.isSimple())
734 if (llvm::GetElementPtrInst *GEP =
735 dyn_cast<llvm::GetElementPtrInst>(FieldLoc.getAddress()))
736 if (GEP->use_empty())
737 GEP->eraseFromParent();
Lauro Ramos Venancio145cd892008-02-19 19:27:31 +0000738 }
Devang Patel636c3d02007-10-26 17:44:44 +0000739}
740
Chris Lattneree755f92007-08-21 04:59:27 +0000741//===----------------------------------------------------------------------===//
742// Entry Points into this File
743//===----------------------------------------------------------------------===//
744
Chris Lattner1b726772010-12-02 07:07:26 +0000745/// GetNumNonZeroBytesInInit - Get an approximate count of the number of
746/// non-zero bytes that will be stored when outputting the initializer for the
747/// specified initializer expression.
748static uint64_t GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) {
749 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E))
750 return GetNumNonZeroBytesInInit(PE->getSubExpr(), CGF);
751
752 // 0 and 0.0 won't require any non-zero stores!
753 if (isSimpleZero(E, CGF)) return 0;
754
755 // If this is an initlist expr, sum up the size of sizes of the (present)
756 // elements. If this is something weird, assume the whole thing is non-zero.
757 const InitListExpr *ILE = dyn_cast<InitListExpr>(E);
758 if (ILE == 0 || !CGF.getTypes().isZeroInitializable(ILE->getType()))
759 return CGF.getContext().getTypeSize(E->getType())/8;
760
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000761 // InitListExprs for structs have to be handled carefully. If there are
762 // reference members, we need to consider the size of the reference, not the
763 // referencee. InitListExprs for unions and arrays can't have references.
Chris Lattner8c00ad12010-12-02 22:52:04 +0000764 if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
765 if (!RT->isUnionType()) {
766 RecordDecl *SD = E->getType()->getAs<RecordType>()->getDecl();
767 uint64_t NumNonZeroBytes = 0;
768
769 unsigned ILEElement = 0;
770 for (RecordDecl::field_iterator Field = SD->field_begin(),
771 FieldEnd = SD->field_end(); Field != FieldEnd; ++Field) {
772 // We're done once we hit the flexible array member or run out of
773 // InitListExpr elements.
774 if (Field->getType()->isIncompleteArrayType() ||
775 ILEElement == ILE->getNumInits())
776 break;
777 if (Field->isUnnamedBitfield())
778 continue;
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000779
Chris Lattner8c00ad12010-12-02 22:52:04 +0000780 const Expr *E = ILE->getInit(ILEElement++);
781
782 // Reference values are always non-null and have the width of a pointer.
783 if (Field->getType()->isReferenceType())
784 NumNonZeroBytes += CGF.getContext().Target.getPointerWidth(0);
785 else
786 NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF);
787 }
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000788
Chris Lattner8c00ad12010-12-02 22:52:04 +0000789 return NumNonZeroBytes;
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000790 }
Chris Lattnerd1d56df2010-12-02 18:29:00 +0000791 }
792
793
Chris Lattner1b726772010-12-02 07:07:26 +0000794 uint64_t NumNonZeroBytes = 0;
795 for (unsigned i = 0, e = ILE->getNumInits(); i != e; ++i)
796 NumNonZeroBytes += GetNumNonZeroBytesInInit(ILE->getInit(i), CGF);
797 return NumNonZeroBytes;
798}
799
800/// CheckAggExprForMemSetUse - If the initializer is large and has a lot of
801/// zeros in it, emit a memset and avoid storing the individual zeros.
802///
803static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,
804 CodeGenFunction &CGF) {
805 // If the slot is already known to be zeroed, nothing to do. Don't mess with
806 // volatile stores.
807 if (Slot.isZeroed() || Slot.isVolatile() || Slot.getAddr() == 0) return;
808
809 // If the type is 16-bytes or smaller, prefer individual stores over memset.
810 std::pair<uint64_t, unsigned> TypeInfo =
811 CGF.getContext().getTypeInfo(E->getType());
812 if (TypeInfo.first/8 <= 16)
813 return;
814
815 // Check to see if over 3/4 of the initializer are known to be zero. If so,
816 // we prefer to emit memset + individual stores for the rest.
817 uint64_t NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF);
818 if (NumNonZeroBytes*4 > TypeInfo.first/8)
819 return;
820
821 // Okay, it seems like a good idea to use an initial memset, emit the call.
822 llvm::Constant *SizeVal = CGF.Builder.getInt64(TypeInfo.first/8);
Benjamin Kramer9f0c7cc2010-12-30 00:13:21 +0000823 unsigned Align = TypeInfo.second/8;
Chris Lattner1b726772010-12-02 07:07:26 +0000824
825 llvm::Value *Loc = Slot.getAddr();
826 const llvm::Type *BP = llvm::Type::getInt8PtrTy(CGF.getLLVMContext());
827
828 Loc = CGF.Builder.CreateBitCast(Loc, BP);
Benjamin Kramer9f0c7cc2010-12-30 00:13:21 +0000829 CGF.Builder.CreateMemSet(Loc, CGF.Builder.getInt8(0), SizeVal, Align, false);
Chris Lattner1b726772010-12-02 07:07:26 +0000830
831 // Tell the AggExprEmitter that the slot is known zero.
832 Slot.setZeroed();
833}
834
835
836
837
Mike Stumpe1129a92009-05-26 18:57:45 +0000838/// EmitAggExpr - Emit the computation of the specified expression of aggregate
839/// type. The result is computed into DestPtr. Note that if DestPtr is null,
840/// the value of the aggregate expression is not needed. If VolatileDest is
841/// true, DestPtr cannot be 0.
John McCall558d2ab2010-09-15 10:14:12 +0000842///
843/// \param IsInitializer - true if this evaluation is initializing an
844/// object whose lifetime is already being managed.
Daniel Dunbar18aba0d2010-02-05 19:38:31 +0000845//
846// FIXME: Take Qualifiers object.
John McCall558d2ab2010-09-15 10:14:12 +0000847void CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot,
Fariborz Jahanian474e2fe2010-09-16 00:20:07 +0000848 bool IgnoreResult) {
Chris Lattneree755f92007-08-21 04:59:27 +0000849 assert(E && hasAggregateLLVMType(E->getType()) &&
850 "Invalid aggregate expression to emit");
Chris Lattner1b726772010-12-02 07:07:26 +0000851 assert((Slot.getAddr() != 0 || Slot.isIgnored()) &&
852 "slot has bits but no address");
Mike Stump1eb44332009-09-09 15:08:12 +0000853
Chris Lattner1b726772010-12-02 07:07:26 +0000854 // Optimize the slot if possible.
855 CheckAggExprForMemSetUse(Slot, E, *this);
856
857 AggExprEmitter(*this, Slot, IgnoreResult).Visit(const_cast<Expr*>(E));
Chris Lattneree755f92007-08-21 04:59:27 +0000858}
Daniel Dunbar7482d122008-09-09 20:49:46 +0000859
Daniel Dunbar18aba0d2010-02-05 19:38:31 +0000860LValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) {
861 assert(hasAggregateLLVMType(E->getType()) && "Invalid argument!");
Daniel Dunbar195337d2010-02-09 02:48:28 +0000862 llvm::Value *Temp = CreateMemTemp(E->getType());
Daniel Dunbar79c39282010-08-21 03:15:20 +0000863 LValue LV = MakeAddrLValue(Temp, E->getType());
Chris Lattner1b726772010-12-02 07:07:26 +0000864 EmitAggExpr(E, AggValueSlot::forAddr(Temp, LV.isVolatileQualified(), false));
Daniel Dunbar79c39282010-08-21 03:15:20 +0000865 return LV;
Daniel Dunbar18aba0d2010-02-05 19:38:31 +0000866}
867
Daniel Dunbar7482d122008-09-09 20:49:46 +0000868void CodeGenFunction::EmitAggregateCopy(llvm::Value *DestPtr,
Mike Stump27fe2e62009-05-23 22:29:41 +0000869 llvm::Value *SrcPtr, QualType Ty,
870 bool isVolatile) {
Daniel Dunbar7482d122008-09-09 20:49:46 +0000871 assert(!Ty->isAnyComplexType() && "Shouldn't happen for complex");
Mike Stump1eb44332009-09-09 15:08:12 +0000872
Anders Carlsson0d7c5832010-05-03 01:20:20 +0000873 if (getContext().getLangOptions().CPlusPlus) {
874 if (const RecordType *RT = Ty->getAs<RecordType>()) {
Douglas Gregore9979482010-05-20 15:39:01 +0000875 CXXRecordDecl *Record = cast<CXXRecordDecl>(RT->getDecl());
876 assert((Record->hasTrivialCopyConstructor() ||
Fariborz Jahanian1d49f212010-05-20 16:46:55 +0000877 Record->hasTrivialCopyAssignment()) &&
Douglas Gregore9979482010-05-20 15:39:01 +0000878 "Trying to aggregate-copy a type without a trivial copy "
879 "constructor or assignment operator");
Douglas Gregor419aa962010-05-20 15:48:29 +0000880 // Ignore empty classes in C++.
Douglas Gregore9979482010-05-20 15:39:01 +0000881 if (Record->isEmpty())
Anders Carlsson0d7c5832010-05-03 01:20:20 +0000882 return;
883 }
884 }
885
Chris Lattner83c96292009-02-28 18:31:01 +0000886 // Aggregate assignment turns into llvm.memcpy. This is almost valid per
Chris Lattnerca4fc2c2009-02-28 18:18:58 +0000887 // C99 6.5.16.1p3, which states "If the value being stored in an object is
888 // read from another object that overlaps in anyway the storage of the first
889 // object, then the overlap shall be exact and the two objects shall have
890 // qualified or unqualified versions of a compatible type."
891 //
Chris Lattner83c96292009-02-28 18:31:01 +0000892 // memcpy is not defined if the source and destination pointers are exactly
Chris Lattnerca4fc2c2009-02-28 18:18:58 +0000893 // equal, but other compilers do this optimization, and almost every memcpy
894 // implementation handles this case safely. If there is a libc that does not
895 // safely handle this, we can add a target hook.
Mike Stump1eb44332009-09-09 15:08:12 +0000896
Daniel Dunbar7482d122008-09-09 20:49:46 +0000897 // Get size and alignment info for this aggregate.
898 std::pair<uint64_t, unsigned> TypeInfo = getContext().getTypeInfo(Ty);
Mike Stump1eb44332009-09-09 15:08:12 +0000899
Daniel Dunbar7482d122008-09-09 20:49:46 +0000900 // FIXME: Handle variable sized types.
Mike Stump1eb44332009-09-09 15:08:12 +0000901
Mike Stumpfde64202009-05-23 04:13:59 +0000902 // FIXME: If we have a volatile struct, the optimizer can remove what might
903 // appear to be `extra' memory ops:
904 //
905 // volatile struct { int i; } a, b;
906 //
907 // int main() {
908 // a = b;
909 // a = b;
910 // }
911 //
Mon P Wang3ecd7852010-04-04 03:10:52 +0000912 // we need to use a different call here. We use isVolatile to indicate when
Mike Stump49d1cd52009-05-26 22:03:21 +0000913 // either the source or the destination is volatile.
Mon P Wang3ecd7852010-04-04 03:10:52 +0000914
915 const llvm::PointerType *DPT = cast<llvm::PointerType>(DestPtr->getType());
Chris Lattner098432c2010-07-08 00:07:45 +0000916 const llvm::Type *DBP =
John McCalld16c2cf2011-02-08 08:22:06 +0000917 llvm::Type::getInt8PtrTy(getLLVMContext(), DPT->getAddressSpace());
Chris Lattner098432c2010-07-08 00:07:45 +0000918 DestPtr = Builder.CreateBitCast(DestPtr, DBP, "tmp");
Mon P Wang3ecd7852010-04-04 03:10:52 +0000919
920 const llvm::PointerType *SPT = cast<llvm::PointerType>(SrcPtr->getType());
Chris Lattner098432c2010-07-08 00:07:45 +0000921 const llvm::Type *SBP =
John McCalld16c2cf2011-02-08 08:22:06 +0000922 llvm::Type::getInt8PtrTy(getLLVMContext(), SPT->getAddressSpace());
Chris Lattner098432c2010-07-08 00:07:45 +0000923 SrcPtr = Builder.CreateBitCast(SrcPtr, SBP, "tmp");
Mon P Wang3ecd7852010-04-04 03:10:52 +0000924
Fariborz Jahanian55bcace2010-06-15 22:44:06 +0000925 if (const RecordType *RecordTy = Ty->getAs<RecordType>()) {
926 RecordDecl *Record = RecordTy->getDecl();
927 if (Record->hasObjectMember()) {
928 unsigned long size = TypeInfo.first/8;
929 const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
930 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size);
931 CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
932 SizeVal);
933 return;
934 }
935 } else if (getContext().getAsArrayType(Ty)) {
936 QualType BaseType = getContext().getBaseElementType(Ty);
937 if (const RecordType *RecordTy = BaseType->getAs<RecordType>()) {
938 if (RecordTy->getDecl()->hasObjectMember()) {
939 unsigned long size = TypeInfo.first/8;
940 const llvm::Type *SizeTy = ConvertType(getContext().getSizeType());
941 llvm::Value *SizeVal = llvm::ConstantInt::get(SizeTy, size);
942 CGM.getObjCRuntime().EmitGCMemmoveCollectable(*this, DestPtr, SrcPtr,
943 SizeVal);
944 return;
945 }
946 }
947 }
948
Benjamin Kramer9f0c7cc2010-12-30 00:13:21 +0000949 Builder.CreateMemCpy(DestPtr, SrcPtr,
950 llvm::ConstantInt::get(IntPtrTy, TypeInfo.first/8),
951 TypeInfo.second/8, isVolatile);
Daniel Dunbar7482d122008-09-09 20:49:46 +0000952}