blob: 4a31bcfbe9e08c678855b7300fd1a21447a6212c [file] [log] [blame]
Chris Lattner11e0de52007-08-24 02:22:53 +00001//===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===//
Chris Lattnercbfc73b2007-08-21 05:54:00 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-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 Lattnercbfc73b2007-08-21 05:54:00 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Expr nodes with complex types as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
15#include "CodeGenModule.h"
Daniel Dunbarad319a72008-08-11 05:00:27 +000016#include "clang/AST/ASTContext.h"
17#include "clang/AST/StmtVisitor.h"
Chris Lattnercbfc73b2007-08-21 05:54:00 +000018#include "llvm/Constants.h"
19#include "llvm/Function.h"
Chris Lattnera8d8b712007-08-26 22:47:40 +000020#include "llvm/ADT/SmallString.h"
Chris Lattnercbfc73b2007-08-21 05:54:00 +000021using namespace clang;
22using namespace CodeGen;
23
24//===----------------------------------------------------------------------===//
Chris Lattnerb01cc9d2007-08-21 05:54:53 +000025// Complex Expression Emitter
Chris Lattnercbfc73b2007-08-21 05:54:00 +000026//===----------------------------------------------------------------------===//
27
Chris Lattner96d72562007-08-21 16:57:55 +000028typedef CodeGenFunction::ComplexPairTy ComplexPairTy;
Chris Lattnercbfc73b2007-08-21 05:54:00 +000029
30namespace {
Benjamin Kramer337e3a52009-11-28 19:45:26 +000031class ComplexExprEmitter
Chris Lattnercbfc73b2007-08-21 05:54:00 +000032 : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> {
33 CodeGenFunction &CGF;
Daniel Dunbarcb463852008-11-01 01:53:16 +000034 CGBuilderTy &Builder;
Mike Stumpdf0fe272009-05-29 15:46:01 +000035 // True is we should ignore the value of a
36 bool IgnoreReal;
37 bool IgnoreImag;
Chris Lattnercbfc73b2007-08-21 05:54:00 +000038public:
John McCall07bb1962010-11-16 10:08:07 +000039 ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false)
40 : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) {
Chris Lattnercbfc73b2007-08-21 05:54:00 +000041 }
42
Mike Stump4a3999f2009-09-09 13:00:44 +000043
Chris Lattnercbfc73b2007-08-21 05:54:00 +000044 //===--------------------------------------------------------------------===//
45 // Utilities
46 //===--------------------------------------------------------------------===//
47
Mike Stumpdf0fe272009-05-29 15:46:01 +000048 bool TestAndClearIgnoreReal() {
49 bool I = IgnoreReal;
50 IgnoreReal = false;
51 return I;
52 }
53 bool TestAndClearIgnoreImag() {
54 bool I = IgnoreImag;
55 IgnoreImag = false;
56 return I;
57 }
Mike Stumpdf0fe272009-05-29 15:46:01 +000058
Chris Lattnercbfc73b2007-08-21 05:54:00 +000059 /// EmitLoadOfLValue - Given an expression with complex type that represents a
60 /// value l-value, this method emits the address of the l-value, then loads
61 /// and returns the result.
Chris Lattner4b0e7872007-08-21 17:28:34 +000062 ComplexPairTy EmitLoadOfLValue(const Expr *E) {
John McCalle26a8722010-12-04 08:14:53 +000063 return EmitLoadOfLValue(CGF.EmitLValue(E));
64 }
65
66 ComplexPairTy EmitLoadOfLValue(LValue LV) {
Daniel Dunbar76d864c2009-06-10 04:38:50 +000067 if (LV.isSimple())
68 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified());
69
John McCallf3eb96f2010-12-04 02:32:38 +000070 assert(LV.isPropertyRef() && "Unknown LValue type!");
71 return CGF.EmitLoadOfPropertyRefLValue(LV).getComplexVal();
Chris Lattner4b0e7872007-08-21 17:28:34 +000072 }
Mike Stump4a3999f2009-09-09 13:00:44 +000073
Chris Lattner4b0e7872007-08-21 17:28:34 +000074 /// EmitLoadOfComplex - Given a pointer to a complex value, emit code to load
75 /// the real and imaginary pieces.
Chris Lattnere0e54122007-08-21 18:02:02 +000076 ComplexPairTy EmitLoadOfComplex(llvm::Value *SrcPtr, bool isVolatile);
Mike Stump4a3999f2009-09-09 13:00:44 +000077
John McCalle26a8722010-12-04 08:14:53 +000078 /// EmitStoreThroughLValue - Given an l-value of complex type, store
79 /// a complex number into it.
80 void EmitStoreThroughLValue(ComplexPairTy Val, LValue LV) {
81 if (LV.isSimple())
82 return EmitStoreOfComplex(Val, LV.getAddress(), LV.isVolatileQualified());
83
84 assert(LV.isPropertyRef() && "Unknown LValue type!");
85 CGF.EmitStoreThroughPropertyRefLValue(RValue::getComplex(Val), LV);
86 }
87
Chris Lattner4b0e7872007-08-21 17:28:34 +000088 /// EmitStoreOfComplex - Store the specified real/imag parts into the
89 /// specified value pointer.
Chris Lattnere0e54122007-08-21 18:02:02 +000090 void EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *ResPtr, bool isVol);
Mike Stump4a3999f2009-09-09 13:00:44 +000091
Chris Lattner624e6d02007-08-26 22:09:01 +000092 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
93 ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType,
94 QualType DestType);
Mike Stump4a3999f2009-09-09 13:00:44 +000095
Chris Lattnercbfc73b2007-08-21 05:54:00 +000096 //===--------------------------------------------------------------------===//
97 // Visitor Methods
98 //===--------------------------------------------------------------------===//
Chris Lattnerd614e7a2007-08-21 18:51:13 +000099
Fariborz Jahanian8162d4a2010-09-20 23:50:22 +0000100 ComplexPairTy Visit(Expr *E) {
John McCalle6be5e12011-02-17 19:02:56 +0000101 return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E);
Fariborz Jahanian8162d4a2010-09-20 23:50:22 +0000102 }
103
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000104 ComplexPairTy VisitStmt(Stmt *S) {
Ted Kremenekd4e5fba2007-12-11 21:27:55 +0000105 S->dump(CGF.getContext().getSourceManager());
David Blaikie83d382b2011-09-23 05:06:16 +0000106 llvm_unreachable("Stmt can't have complex result type!");
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000107 }
Chris Lattnerd614e7a2007-08-21 18:51:13 +0000108 ComplexPairTy VisitExpr(Expr *S);
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000109 ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
Peter Collingbourne91147592011-04-15 00:35:48 +0000110 ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
111 return Visit(GE->getResultExpr());
112 }
Chris Lattner7460f962007-08-26 05:57:57 +0000113 ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL);
John McCall7c454bb2011-07-15 05:09:51 +0000114 ComplexPairTy
115 VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
116 return Visit(PE->getReplacement());
117 }
Mike Stump4a3999f2009-09-09 13:00:44 +0000118
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000119 // l-values.
Chris Lattner7460f962007-08-26 05:57:57 +0000120 ComplexPairTy VisitDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); }
Fariborz Jahanian2bb82702011-09-02 21:33:44 +0000121 ComplexPairTy VisitBlockDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); }
Mike Stump4a3999f2009-09-09 13:00:44 +0000122 ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
Daniel Dunbar76d864c2009-06-10 04:38:50 +0000123 return EmitLoadOfLValue(E);
124 }
125 ComplexPairTy VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
John McCall34376a62010-12-04 03:47:34 +0000126 assert(E->getObjectKind() == OK_Ordinary);
Daniel Dunbar76d864c2009-06-10 04:38:50 +0000127 return EmitLoadOfLValue(E);
128 }
Daniel Dunbar76d864c2009-06-10 04:38:50 +0000129 ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) {
130 return CGF.EmitObjCMessageExpr(E).getComplexVal();
131 }
Chris Lattnera0733a72007-08-21 18:03:58 +0000132 ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); }
Chris Lattner7460f962007-08-26 05:57:57 +0000133 ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); }
John McCall1bf58462011-02-16 08:02:54 +0000134 ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) {
John McCallc07a0c72011-02-17 10:25:35 +0000135 if (E->isGLValue())
136 return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E));
137 return CGF.getOpaqueRValueMapping(E).getComplexVal();
John McCall1bf58462011-02-16 08:02:54 +0000138 }
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000139
Chris Lattnercb1ffbc2007-08-21 22:33:41 +0000140 // FIXME: CompoundLiteralExpr
Mike Stump4a3999f2009-09-09 13:00:44 +0000141
Douglas Gregorc357f412010-07-14 21:35:45 +0000142 ComplexPairTy EmitCast(CastExpr::CastKind CK, Expr *Op, QualType DestTy);
Chris Lattner7460f962007-08-26 05:57:57 +0000143 ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) {
144 // Unlike for scalars, we don't have to worry about function->ptr demotion
145 // here.
Douglas Gregorc357f412010-07-14 21:35:45 +0000146 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
Chris Lattner7460f962007-08-26 05:57:57 +0000147 }
148 ComplexPairTy VisitCastExpr(CastExpr *E) {
Douglas Gregorc357f412010-07-14 21:35:45 +0000149 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
Chris Lattner7460f962007-08-26 05:57:57 +0000150 }
Chris Lattner1aaab492007-08-23 21:38:16 +0000151 ComplexPairTy VisitCallExpr(const CallExpr *E);
Chris Lattner1c3ad192007-08-31 22:51:38 +0000152 ComplexPairTy VisitStmtExpr(const StmtExpr *E);
153
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000154 // Operators.
Chris Lattnerd34c9992007-08-21 22:25:29 +0000155 ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E,
Chris Lattner116ce8f2010-01-09 21:40:03 +0000156 bool isInc, bool isPre) {
157 LValue LV = CGF.EmitLValue(E->getSubExpr());
158 return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre);
159 }
Chris Lattnerd34c9992007-08-21 22:25:29 +0000160 ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) {
161 return VisitPrePostIncDec(E, false, false);
162 }
163 ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) {
164 return VisitPrePostIncDec(E, true, false);
165 }
166 ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) {
167 return VisitPrePostIncDec(E, false, true);
168 }
169 ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) {
170 return VisitPrePostIncDec(E, true, true);
171 }
172 ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
Chris Lattnerad4569e2007-08-21 20:08:23 +0000173 ComplexPairTy VisitUnaryPlus (const UnaryOperator *E) {
Mike Stumpdf0fe272009-05-29 15:46:01 +0000174 TestAndClearIgnoreReal();
175 TestAndClearIgnoreImag();
Chris Lattnerad4569e2007-08-21 20:08:23 +0000176 return Visit(E->getSubExpr());
177 }
178 ComplexPairTy VisitUnaryMinus (const UnaryOperator *E);
Chris Lattner875a5192007-08-21 20:41:44 +0000179 ComplexPairTy VisitUnaryNot (const UnaryOperator *E);
Sebastian Redl6f282892008-11-11 17:56:53 +0000180 // LNot,Real,Imag never return complex.
Chris Lattner875a5192007-08-21 20:41:44 +0000181 ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) {
182 return Visit(E->getSubExpr());
183 }
Chris Lattneraa9c7ae2008-04-08 04:40:51 +0000184 ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
185 return Visit(DAE->getExpr());
186 }
John McCall5d413782010-12-06 08:20:24 +0000187 ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) {
188 return CGF.EmitExprWithCleanups(E).getComplexVal();
Anders Carlssonc0092ad2009-05-31 00:12:05 +0000189 }
Douglas Gregor747eb782010-07-08 06:14:04 +0000190 ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
Argyrios Kyrtzidisce4528f2008-08-23 19:35:47 +0000191 assert(E->getType()->isAnyComplexType() && "Expected complex type!");
John McCall9dd450b2009-09-21 23:43:11 +0000192 QualType Elem = E->getType()->getAs<ComplexType>()->getElementType();
Mike Stump4a3999f2009-09-09 13:00:44 +0000193 llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem));
Argyrios Kyrtzidisce4528f2008-08-23 19:35:47 +0000194 return ComplexPairTy(Null, Null);
195 }
Douglas Gregor0202cb42009-01-29 17:44:32 +0000196 ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
197 assert(E->getType()->isAnyComplexType() && "Expected complex type!");
John McCall9dd450b2009-09-21 23:43:11 +0000198 QualType Elem = E->getType()->getAs<ComplexType>()->getElementType();
Mike Stump4a3999f2009-09-09 13:00:44 +0000199 llvm::Constant *Null =
Owen Anderson0b75f232009-07-31 20:28:54 +0000200 llvm::Constant::getNullValue(CGF.ConvertType(Elem));
Douglas Gregor0202cb42009-01-29 17:44:32 +0000201 return ComplexPairTy(Null, Null);
202 }
Mike Stump4a3999f2009-09-09 13:00:44 +0000203
Chris Lattner624e6d02007-08-26 22:09:01 +0000204 struct BinOpInfo {
205 ComplexPairTy LHS;
206 ComplexPairTy RHS;
207 QualType Ty; // Computation Type.
Mike Stump4a3999f2009-09-09 13:00:44 +0000208 };
209
Chris Lattner624e6d02007-08-26 22:09:01 +0000210 BinOpInfo EmitBinOps(const BinaryOperator *E);
John McCall07bb1962010-11-16 10:08:07 +0000211 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
212 ComplexPairTy (ComplexExprEmitter::*Func)
213 (const BinOpInfo &),
214 ComplexPairTy &Val);
Chris Lattner624e6d02007-08-26 22:09:01 +0000215 ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E,
216 ComplexPairTy (ComplexExprEmitter::*Func)
217 (const BinOpInfo &));
218
219 ComplexPairTy EmitBinAdd(const BinOpInfo &Op);
220 ComplexPairTy EmitBinSub(const BinOpInfo &Op);
221 ComplexPairTy EmitBinMul(const BinOpInfo &Op);
222 ComplexPairTy EmitBinDiv(const BinOpInfo &Op);
Mike Stump4a3999f2009-09-09 13:00:44 +0000223
Chris Lattner624e6d02007-08-26 22:09:01 +0000224 ComplexPairTy VisitBinAdd(const BinaryOperator *E) {
225 return EmitBinAdd(EmitBinOps(E));
226 }
227 ComplexPairTy VisitBinSub(const BinaryOperator *E) {
228 return EmitBinSub(EmitBinOps(E));
229 }
John McCall07bb1962010-11-16 10:08:07 +0000230 ComplexPairTy VisitBinMul(const BinaryOperator *E) {
231 return EmitBinMul(EmitBinOps(E));
232 }
Chris Lattner624e6d02007-08-26 22:09:01 +0000233 ComplexPairTy VisitBinDiv(const BinaryOperator *E) {
234 return EmitBinDiv(EmitBinOps(E));
235 }
Mike Stump4a3999f2009-09-09 13:00:44 +0000236
Chris Lattner624e6d02007-08-26 22:09:01 +0000237 // Compound assignments.
238 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) {
239 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd);
240 }
241 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) {
242 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub);
243 }
244 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) {
245 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul);
246 }
247 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) {
248 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv);
249 }
Mike Stump4a3999f2009-09-09 13:00:44 +0000250
Chris Lattner2c666fa2007-08-26 21:27:07 +0000251 // GCC rejects rem/and/or/xor for integer complex.
Chris Lattner64be48f2007-08-21 17:12:50 +0000252 // Logical and/or always return int, never complex.
Chris Lattner96d72562007-08-21 16:57:55 +0000253
254 // No comparisons produce a complex result.
John McCall07bb1962010-11-16 10:08:07 +0000255
256 LValue EmitBinAssignLValue(const BinaryOperator *E,
257 ComplexPairTy &Val);
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000258 ComplexPairTy VisitBinAssign (const BinaryOperator *E);
Chris Lattner3cf417b2007-08-21 17:15:50 +0000259 ComplexPairTy VisitBinComma (const BinaryOperator *E);
260
Mike Stump4a3999f2009-09-09 13:00:44 +0000261
John McCallc07a0c72011-02-17 10:25:35 +0000262 ComplexPairTy
263 VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
Chris Lattnerdb0d60d2007-08-24 02:18:47 +0000264 ComplexPairTy VisitChooseExpr(ChooseExpr *CE);
Eli Friedmandd7406e2008-05-13 23:11:35 +0000265
266 ComplexPairTy VisitInitListExpr(InitListExpr *E);
Daniel Dunbar00079612009-02-10 03:03:30 +0000267
268 ComplexPairTy VisitVAArgExpr(VAArgExpr *E);
Eli Friedmandf14b3a2011-10-11 02:20:01 +0000269
270 ComplexPairTy VisitAtomicExpr(AtomicExpr *E) {
271 return CGF.EmitAtomicExpr(E).getComplexVal();
272 }
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000273};
274} // end anonymous namespace.
275
276//===----------------------------------------------------------------------===//
277// Utilities
278//===----------------------------------------------------------------------===//
279
Chris Lattner4b0e7872007-08-21 17:28:34 +0000280/// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to
281/// load the real and imaginary pieces, returning them as Real/Imag.
Chris Lattnere0e54122007-08-21 18:02:02 +0000282ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr,
283 bool isVolatile) {
Mike Stumpdf0fe272009-05-29 15:46:01 +0000284 llvm::Value *Real=0, *Imag=0;
Chris Lattnera8d8b712007-08-26 22:47:40 +0000285
John McCall83fe49d2010-11-14 09:40:28 +0000286 if (!IgnoreReal || isVolatile) {
Benjamin Kramerba9fd982009-11-29 19:51:45 +0000287 llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0,
288 SrcPtr->getName() + ".realp");
289 Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr->getName() + ".real");
Mike Stumpdf0fe272009-05-29 15:46:01 +0000290 }
Mike Stump4a3999f2009-09-09 13:00:44 +0000291
John McCall83fe49d2010-11-14 09:40:28 +0000292 if (!IgnoreImag || isVolatile) {
Benjamin Kramerba9fd982009-11-29 19:51:45 +0000293 llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1,
294 SrcPtr->getName() + ".imagp");
295 Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr->getName() + ".imag");
Mike Stumpdf0fe272009-05-29 15:46:01 +0000296 }
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000297 return ComplexPairTy(Real, Imag);
298}
299
Chris Lattner4b0e7872007-08-21 17:28:34 +0000300/// EmitStoreOfComplex - Store the specified real/imag parts into the
301/// specified value pointer.
Chris Lattnere0e54122007-08-21 18:02:02 +0000302void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *Ptr,
303 bool isVolatile) {
Chris Lattner3e593cd2008-03-19 05:19:41 +0000304 llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real");
305 llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag");
Mike Stump4a3999f2009-09-09 13:00:44 +0000306
Chris Lattnere0e54122007-08-21 18:02:02 +0000307 Builder.CreateStore(Val.first, RealPtr, isVolatile);
308 Builder.CreateStore(Val.second, ImagPtr, isVolatile);
Chris Lattner4b0e7872007-08-21 17:28:34 +0000309}
310
311
312
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000313//===----------------------------------------------------------------------===//
314// Visitor Methods
315//===----------------------------------------------------------------------===//
316
Chris Lattnerd614e7a2007-08-21 18:51:13 +0000317ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
Fariborz Jahanianb74711d2011-09-02 20:03:16 +0000318 CGF.ErrorUnsupported(E, "complex expression");
319 llvm::Type *EltTy =
320 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType());
321 llvm::Value *U = llvm::UndefValue::get(EltTy);
322 return ComplexPairTy(U, U);
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000323}
324
Chris Lattner7460f962007-08-26 05:57:57 +0000325ComplexPairTy ComplexExprEmitter::
326VisitImaginaryLiteral(const ImaginaryLiteral *IL) {
Chris Lattner0fffcb52007-08-26 03:51:12 +0000327 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr());
John McCall294c2db2011-01-13 02:03:06 +0000328 return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag);
Chris Lattner0fffcb52007-08-26 03:51:12 +0000329}
330
331
Chris Lattner1aaab492007-08-23 21:38:16 +0000332ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
Anders Carlssond8b7ae22009-05-27 03:37:57 +0000333 if (E->getCallReturnType()->isReferenceType())
334 return EmitLoadOfLValue(E);
335
Chris Lattner4647a212007-08-31 22:49:20 +0000336 return CGF.EmitCallExpr(E).getComplexVal();
Chris Lattner1aaab492007-08-23 21:38:16 +0000337}
338
Chris Lattner1c3ad192007-08-31 22:51:38 +0000339ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) {
John McCallce1de612011-01-26 04:00:11 +0000340 CodeGenFunction::StmtExprEvaluation eval(CGF);
341 return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal();
Chris Lattner1c3ad192007-08-31 22:51:38 +0000342}
343
Chris Lattner624e6d02007-08-26 22:09:01 +0000344/// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
345ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val,
346 QualType SrcType,
347 QualType DestType) {
348 // Get the src/dest element type.
John McCall9dd450b2009-09-21 23:43:11 +0000349 SrcType = SrcType->getAs<ComplexType>()->getElementType();
350 DestType = DestType->getAs<ComplexType>()->getElementType();
Chris Lattner7460f962007-08-26 05:57:57 +0000351
Daniel Dunbardc8b4b02009-01-29 06:44:03 +0000352 // C99 6.3.1.6: When a value of complex type is converted to another
Daniel Dunbar02fe8212009-01-26 18:02:34 +0000353 // complex type, both the real and imaginary parts follow the conversion
Chris Lattner624e6d02007-08-26 22:09:01 +0000354 // rules for the corresponding real types.
355 Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType);
356 Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType);
357 return Val;
358}
359
Douglas Gregorc357f412010-07-14 21:35:45 +0000360ComplexPairTy ComplexExprEmitter::EmitCast(CastExpr::CastKind CK, Expr *Op,
361 QualType DestTy) {
John McCall34376a62010-12-04 03:47:34 +0000362 switch (CK) {
Eli Friedman58368522011-06-25 02:58:47 +0000363 case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!");
364
John McCall34376a62010-12-04 03:47:34 +0000365 case CK_GetObjCProperty: {
366 LValue LV = CGF.EmitLValue(Op);
367 assert(LV.isPropertyRef() && "Unknown LValue type!");
368 return CGF.EmitLoadOfPropertyRefLValue(LV).getComplexVal();
369 }
370
371 case CK_NoOp:
372 case CK_LValueToRValue:
Eli Friedman58368522011-06-25 02:58:47 +0000373 case CK_UserDefinedConversion:
John McCall34376a62010-12-04 03:47:34 +0000374 return Visit(Op);
375
Eli Friedman58368522011-06-25 02:58:47 +0000376 case CK_LValueBitCast: {
Douglas Gregorc357f412010-07-14 21:35:45 +0000377 llvm::Value *V = CGF.EmitLValue(Op).getAddress();
378 V = Builder.CreateBitCast(V,
Eli Friedman58368522011-06-25 02:58:47 +0000379 CGF.ConvertType(CGF.getContext().getPointerType(DestTy)));
Douglas Gregorc357f412010-07-14 21:35:45 +0000380 // FIXME: Are the qualifiers correct here?
381 return EmitLoadOfComplex(V, DestTy.isVolatileQualified());
382 }
Chris Lattner7460f962007-08-26 05:57:57 +0000383
Eli Friedman58368522011-06-25 02:58:47 +0000384 case CK_BitCast:
385 case CK_BaseToDerived:
386 case CK_DerivedToBase:
387 case CK_UncheckedDerivedToBase:
388 case CK_Dynamic:
389 case CK_ToUnion:
390 case CK_ArrayToPointerDecay:
391 case CK_FunctionToPointerDecay:
392 case CK_NullToPointer:
393 case CK_NullToMemberPointer:
394 case CK_BaseToDerivedMemberPointer:
395 case CK_DerivedToBaseMemberPointer:
396 case CK_MemberPointerToBoolean:
397 case CK_ConstructorConversion:
398 case CK_IntegralToPointer:
399 case CK_PointerToIntegral:
400 case CK_PointerToBoolean:
401 case CK_ToVoid:
402 case CK_VectorSplat:
403 case CK_IntegralCast:
404 case CK_IntegralToBoolean:
405 case CK_IntegralToFloating:
406 case CK_FloatingToIntegral:
407 case CK_FloatingToBoolean:
408 case CK_FloatingCast:
John McCall9320b872011-09-09 05:25:32 +0000409 case CK_CPointerToObjCPointerCast:
410 case CK_BlockPointerToObjCPointerCast:
Eli Friedman58368522011-06-25 02:58:47 +0000411 case CK_AnyPointerToBlockPointerCast:
412 case CK_ObjCObjectLValueCast:
413 case CK_FloatingComplexToReal:
414 case CK_FloatingComplexToBoolean:
415 case CK_IntegralComplexToReal:
416 case CK_IntegralComplexToBoolean:
John McCall2d637d22011-09-10 06:18:15 +0000417 case CK_ARCProduceObject:
418 case CK_ARCConsumeObject:
419 case CK_ARCReclaimReturnedObject:
420 case CK_ARCExtendBlockObject:
Eli Friedman58368522011-06-25 02:58:47 +0000421 llvm_unreachable("invalid cast kind for complex value");
Mike Stump4a3999f2009-09-09 13:00:44 +0000422
Eli Friedman58368522011-06-25 02:58:47 +0000423 case CK_FloatingRealToComplex:
424 case CK_IntegralRealToComplex: {
425 llvm::Value *Elt = CGF.EmitScalarExpr(Op);
426
427 // Convert the input element to the element type of the complex.
428 DestTy = DestTy->getAs<ComplexType>()->getElementType();
429 Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy);
430
431 // Return (realval, 0).
432 return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType()));
433 }
434
435 case CK_FloatingComplexCast:
436 case CK_FloatingComplexToIntegralComplex:
437 case CK_IntegralComplexCast:
438 case CK_IntegralComplexToFloatingComplex:
439 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy);
440 }
441
442 llvm_unreachable("unknown cast resulting in complex value");
Chris Lattner7460f962007-08-26 05:57:57 +0000443}
444
Chris Lattnerad4569e2007-08-21 20:08:23 +0000445ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
Mike Stumpdf0fe272009-05-29 15:46:01 +0000446 TestAndClearIgnoreReal();
447 TestAndClearIgnoreImag();
Chris Lattnerad4569e2007-08-21 20:08:23 +0000448 ComplexPairTy Op = Visit(E->getSubExpr());
Mike Stump4a3999f2009-09-09 13:00:44 +0000449
Chris Lattner94dfae22009-06-17 06:36:24 +0000450 llvm::Value *ResR, *ResI;
Duncan Sands998f9d92010-02-15 16:14:01 +0000451 if (Op.first->getType()->isFloatingPointTy()) {
Chris Lattner94dfae22009-06-17 06:36:24 +0000452 ResR = Builder.CreateFNeg(Op.first, "neg.r");
453 ResI = Builder.CreateFNeg(Op.second, "neg.i");
454 } else {
455 ResR = Builder.CreateNeg(Op.first, "neg.r");
456 ResI = Builder.CreateNeg(Op.second, "neg.i");
457 }
Chris Lattnerad4569e2007-08-21 20:08:23 +0000458 return ComplexPairTy(ResR, ResI);
459}
460
Chris Lattner875a5192007-08-21 20:41:44 +0000461ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
Mike Stumpdf0fe272009-05-29 15:46:01 +0000462 TestAndClearIgnoreReal();
463 TestAndClearIgnoreImag();
Chris Lattner875a5192007-08-21 20:41:44 +0000464 // ~(a+ib) = a + i*-b
465 ComplexPairTy Op = Visit(E->getSubExpr());
Chris Lattner94dfae22009-06-17 06:36:24 +0000466 llvm::Value *ResI;
Duncan Sands998f9d92010-02-15 16:14:01 +0000467 if (Op.second->getType()->isFloatingPointTy())
Chris Lattner94dfae22009-06-17 06:36:24 +0000468 ResI = Builder.CreateFNeg(Op.second, "conj.i");
469 else
470 ResI = Builder.CreateNeg(Op.second, "conj.i");
Mike Stump4a3999f2009-09-09 13:00:44 +0000471
Chris Lattner875a5192007-08-21 20:41:44 +0000472 return ComplexPairTy(Op.first, ResI);
473}
Chris Lattnerad4569e2007-08-21 20:08:23 +0000474
Chris Lattner624e6d02007-08-26 22:09:01 +0000475ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) {
Chris Lattner94dfae22009-06-17 06:36:24 +0000476 llvm::Value *ResR, *ResI;
Mike Stump4a3999f2009-09-09 13:00:44 +0000477
Duncan Sands998f9d92010-02-15 16:14:01 +0000478 if (Op.LHS.first->getType()->isFloatingPointTy()) {
Chris Lattner94dfae22009-06-17 06:36:24 +0000479 ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r");
480 ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i");
481 } else {
482 ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r");
483 ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i");
484 }
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000485 return ComplexPairTy(ResR, ResI);
486}
487
Chris Lattner624e6d02007-08-26 22:09:01 +0000488ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) {
Chris Lattner94dfae22009-06-17 06:36:24 +0000489 llvm::Value *ResR, *ResI;
Duncan Sands998f9d92010-02-15 16:14:01 +0000490 if (Op.LHS.first->getType()->isFloatingPointTy()) {
Chris Lattner94dfae22009-06-17 06:36:24 +0000491 ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r");
492 ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i");
493 } else {
494 ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r");
495 ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i");
496 }
Chris Lattner0b984992007-08-23 23:46:33 +0000497 return ComplexPairTy(ResR, ResI);
498}
499
500
Chris Lattner624e6d02007-08-26 22:09:01 +0000501ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) {
Chris Lattner94dfae22009-06-17 06:36:24 +0000502 using llvm::Value;
503 Value *ResR, *ResI;
Mike Stump4a3999f2009-09-09 13:00:44 +0000504
Duncan Sands998f9d92010-02-15 16:14:01 +0000505 if (Op.LHS.first->getType()->isFloatingPointTy()) {
Chris Lattner94dfae22009-06-17 06:36:24 +0000506 Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl");
507 Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr");
508 ResR = Builder.CreateFSub(ResRl, ResRr, "mul.r");
Mike Stump4a3999f2009-09-09 13:00:44 +0000509
Chris Lattner94dfae22009-06-17 06:36:24 +0000510 Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il");
511 Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir");
512 ResI = Builder.CreateFAdd(ResIl, ResIr, "mul.i");
513 } else {
514 Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl");
515 Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr");
516 ResR = Builder.CreateSub(ResRl, ResRr, "mul.r");
Mike Stump4a3999f2009-09-09 13:00:44 +0000517
Chris Lattner94dfae22009-06-17 06:36:24 +0000518 Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il");
519 Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir");
520 ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i");
521 }
Chris Lattner6ce75df2007-08-21 16:34:16 +0000522 return ComplexPairTy(ResR, ResI);
523}
524
Chris Lattner624e6d02007-08-26 22:09:01 +0000525ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) {
526 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
527 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
Mike Stump4a3999f2009-09-09 13:00:44 +0000528
Chris Lattner6f672c12007-08-26 21:24:19 +0000529
530 llvm::Value *DSTr, *DSTi;
Duncan Sands998f9d92010-02-15 16:14:01 +0000531 if (Op.LHS.first->getType()->isFloatingPointTy()) {
Chris Lattner94dfae22009-06-17 06:36:24 +0000532 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
Benjamin Kramer76399eb2011-09-27 21:06:10 +0000533 llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr); // a*c
534 llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi); // b*d
535 llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2); // ac+bd
Mike Stump4a3999f2009-09-09 13:00:44 +0000536
Benjamin Kramer76399eb2011-09-27 21:06:10 +0000537 llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr); // c*c
538 llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi); // d*d
539 llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5); // cc+dd
Mike Stump4a3999f2009-09-09 13:00:44 +0000540
Benjamin Kramer76399eb2011-09-27 21:06:10 +0000541 llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr); // b*c
542 llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi); // a*d
543 llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8); // bc-ad
Mike Stump4a3999f2009-09-09 13:00:44 +0000544
Benjamin Kramer76399eb2011-09-27 21:06:10 +0000545 DSTr = Builder.CreateFDiv(Tmp3, Tmp6);
546 DSTi = Builder.CreateFDiv(Tmp9, Tmp6);
Chris Lattner6f672c12007-08-26 21:24:19 +0000547 } else {
Chris Lattner94dfae22009-06-17 06:36:24 +0000548 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
Benjamin Kramer76399eb2011-09-27 21:06:10 +0000549 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c
550 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d
551 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd
Mike Stump4a3999f2009-09-09 13:00:44 +0000552
Benjamin Kramer76399eb2011-09-27 21:06:10 +0000553 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c
554 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d
555 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd
Mike Stump4a3999f2009-09-09 13:00:44 +0000556
Benjamin Kramer76399eb2011-09-27 21:06:10 +0000557 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c
558 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d
559 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad
Mike Stump4a3999f2009-09-09 13:00:44 +0000560
John McCall9dd450b2009-09-21 23:43:11 +0000561 if (Op.Ty->getAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) {
Benjamin Kramer76399eb2011-09-27 21:06:10 +0000562 DSTr = Builder.CreateUDiv(Tmp3, Tmp6);
563 DSTi = Builder.CreateUDiv(Tmp9, Tmp6);
Chris Lattner6f672c12007-08-26 21:24:19 +0000564 } else {
Benjamin Kramer76399eb2011-09-27 21:06:10 +0000565 DSTr = Builder.CreateSDiv(Tmp3, Tmp6);
566 DSTi = Builder.CreateSDiv(Tmp9, Tmp6);
Chris Lattner6f672c12007-08-26 21:24:19 +0000567 }
568 }
Mike Stump4a3999f2009-09-09 13:00:44 +0000569
Chris Lattner6f672c12007-08-26 21:24:19 +0000570 return ComplexPairTy(DSTr, DSTi);
571}
572
Mike Stump4a3999f2009-09-09 13:00:44 +0000573ComplexExprEmitter::BinOpInfo
Chris Lattner624e6d02007-08-26 22:09:01 +0000574ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) {
Mike Stumpdf0fe272009-05-29 15:46:01 +0000575 TestAndClearIgnoreReal();
576 TestAndClearIgnoreImag();
Chris Lattner624e6d02007-08-26 22:09:01 +0000577 BinOpInfo Ops;
578 Ops.LHS = Visit(E->getLHS());
579 Ops.RHS = Visit(E->getRHS());
580 Ops.Ty = E->getType();
581 return Ops;
582}
583
584
John McCall07bb1962010-11-16 10:08:07 +0000585LValue ComplexExprEmitter::
586EmitCompoundAssignLValue(const CompoundAssignOperator *E,
587 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&),
588 ComplexPairTy &Val) {
Mike Stumpdf0fe272009-05-29 15:46:01 +0000589 TestAndClearIgnoreReal();
590 TestAndClearIgnoreImag();
Jeffrey Yasskin8dfa5f12011-01-18 02:00:16 +0000591 QualType LHSTy = E->getLHS()->getType();
Chris Lattner624e6d02007-08-26 22:09:01 +0000592
593 BinOpInfo OpInfo;
Mike Stump4a3999f2009-09-09 13:00:44 +0000594
Mike Stumpdf0fe272009-05-29 15:46:01 +0000595 // Load the RHS and LHS operands.
596 // __block variables need to have the rhs evaluated first, plus this should
John McCallfa8edb12010-11-16 05:45:35 +0000597 // improve codegen a little.
Eli Friedman8b7b1b12009-03-28 01:22:36 +0000598 OpInfo.Ty = E->getComputationResultType();
John McCallfa8edb12010-11-16 05:45:35 +0000599
600 // The RHS should have been converted to the computation type.
601 assert(OpInfo.Ty->isAnyComplexType());
602 assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty,
603 E->getRHS()->getType()));
604 OpInfo.RHS = Visit(E->getRHS());
Fariborz Jahanian31314962010-03-23 18:08:50 +0000605
Daniel Dunbar8c94ffe2010-06-29 22:44:21 +0000606 LValue LHS = CGF.EmitLValue(E->getLHS());
John McCalle26a8722010-12-04 08:14:53 +0000607
608 // Load from the l-value.
609 ComplexPairTy LHSComplexPair = EmitLoadOfLValue(LHS);
Fariborz Jahanian31314962010-03-23 18:08:50 +0000610
Daniel Dunbar8c94ffe2010-06-29 22:44:21 +0000611 OpInfo.LHS = EmitComplexToComplexCast(LHSComplexPair, LHSTy, OpInfo.Ty);
Mike Stump4a3999f2009-09-09 13:00:44 +0000612
Chris Lattner624e6d02007-08-26 22:09:01 +0000613 // Expand the binary operator.
614 ComplexPairTy Result = (this->*Func)(OpInfo);
Mike Stump4a3999f2009-09-09 13:00:44 +0000615
Chris Lattner624e6d02007-08-26 22:09:01 +0000616 // Truncate the result back to the LHS type.
617 Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy);
John McCall07bb1962010-11-16 10:08:07 +0000618 Val = Result;
Mike Stump4a3999f2009-09-09 13:00:44 +0000619
Chris Lattner624e6d02007-08-26 22:09:01 +0000620 // Store the result value into the LHS lvalue.
John McCalle26a8722010-12-04 08:14:53 +0000621 EmitStoreThroughLValue(Result, LHS);
Daniel Dunbar8c94ffe2010-06-29 22:44:21 +0000622
John McCall07bb1962010-11-16 10:08:07 +0000623 return LHS;
Chris Lattner624e6d02007-08-26 22:09:01 +0000624}
Chris Lattner6f672c12007-08-26 21:24:19 +0000625
John McCall07bb1962010-11-16 10:08:07 +0000626// Compound assignments.
627ComplexPairTy ComplexExprEmitter::
628EmitCompoundAssign(const CompoundAssignOperator *E,
629 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){
630 ComplexPairTy Val;
631 LValue LV = EmitCompoundAssignLValue(E, Func, Val);
632
633 // The result of an assignment in C is the assigned r-value.
634 if (!CGF.getContext().getLangOptions().CPlusPlus)
635 return Val;
636
637 // Objective-C property assignment never reloads the value following a store.
John McCallf3eb96f2010-12-04 02:32:38 +0000638 if (LV.isPropertyRef())
John McCall07bb1962010-11-16 10:08:07 +0000639 return Val;
640
641 // If the lvalue is non-volatile, return the computed value of the assignment.
642 if (!LV.isVolatileQualified())
643 return Val;
644
645 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified());
646}
647
648LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E,
649 ComplexPairTy &Val) {
Douglas Gregora8a089b2010-07-13 18:40:04 +0000650 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
651 E->getRHS()->getType()) &&
Chris Lattner0f398c42008-07-26 22:37:01 +0000652 "Invalid assignment");
John McCall07bb1962010-11-16 10:08:07 +0000653 TestAndClearIgnoreReal();
654 TestAndClearIgnoreImag();
655
John McCalld0a30012010-12-06 06:10:02 +0000656 // Emit the RHS. __block variables need the RHS evaluated first.
John McCall07bb1962010-11-16 10:08:07 +0000657 Val = Visit(E->getRHS());
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000658
659 // Compute the address to store into.
660 LValue LHS = CGF.EmitLValue(E->getLHS());
Mike Stump4a3999f2009-09-09 13:00:44 +0000661
Daniel Dunbar8c94ffe2010-06-29 22:44:21 +0000662 // Store the result value into the LHS lvalue.
John McCalle26a8722010-12-04 08:14:53 +0000663 EmitStoreThroughLValue(Val, LHS);
Daniel Dunbar76d864c2009-06-10 04:38:50 +0000664
John McCall07bb1962010-11-16 10:08:07 +0000665 return LHS;
666}
Daniel Dunbar8c94ffe2010-06-29 22:44:21 +0000667
John McCall07bb1962010-11-16 10:08:07 +0000668ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
669 ComplexPairTy Val;
670 LValue LV = EmitBinAssignLValue(E, Val);
671
672 // The result of an assignment in C is the assigned r-value.
673 if (!CGF.getContext().getLangOptions().CPlusPlus)
674 return Val;
675
676 // Objective-C property assignment never reloads the value following a store.
John McCallf3eb96f2010-12-04 02:32:38 +0000677 if (LV.isPropertyRef())
John McCall07bb1962010-11-16 10:08:07 +0000678 return Val;
679
680 // If the lvalue is non-volatile, return the computed value of the assignment.
681 if (!LV.isVolatileQualified())
682 return Val;
683
684 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified());
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000685}
686
Chris Lattner3cf417b2007-08-21 17:15:50 +0000687ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) {
John McCalla2342eb2010-12-05 02:00:02 +0000688 CGF.EmitIgnoredExpr(E->getLHS());
Chris Lattner3cf417b2007-08-21 17:15:50 +0000689 return Visit(E->getRHS());
690}
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000691
692ComplexPairTy ComplexExprEmitter::
John McCallc07a0c72011-02-17 10:25:35 +0000693VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
Mike Stumpdf0fe272009-05-29 15:46:01 +0000694 TestAndClearIgnoreReal();
695 TestAndClearIgnoreImag();
Daniel Dunbara612e792008-11-13 01:38:36 +0000696 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
697 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
698 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
Mike Stump4a3999f2009-09-09 13:00:44 +0000699
John McCallc07a0c72011-02-17 10:25:35 +0000700 // Bind the common expression if necessary.
701 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
John McCallce1de612011-01-26 04:00:11 +0000702
John McCallc07a0c72011-02-17 10:25:35 +0000703 CodeGenFunction::ConditionalEvaluation eval(CGF);
704 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
Mike Stump4a3999f2009-09-09 13:00:44 +0000705
John McCallce1de612011-01-26 04:00:11 +0000706 eval.begin(CGF);
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000707 CGF.EmitBlock(LHSBlock);
Fariborz Jahanian8162d4a2010-09-20 23:50:22 +0000708 ComplexPairTy LHS = Visit(E->getTrueExpr());
Chris Lattner2dc2af352007-08-21 17:39:38 +0000709 LHSBlock = Builder.GetInsertBlock();
Daniel Dunbarc56e6762008-11-11 09:41:28 +0000710 CGF.EmitBranch(ContBlock);
John McCallce1de612011-01-26 04:00:11 +0000711 eval.end(CGF);
Mike Stump4a3999f2009-09-09 13:00:44 +0000712
John McCallce1de612011-01-26 04:00:11 +0000713 eval.begin(CGF);
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000714 CGF.EmitBlock(RHSBlock);
John McCallc07a0c72011-02-17 10:25:35 +0000715 ComplexPairTy RHS = Visit(E->getFalseExpr());
Chris Lattner2dc2af352007-08-21 17:39:38 +0000716 RHSBlock = Builder.GetInsertBlock();
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000717 CGF.EmitBlock(ContBlock);
John McCallce1de612011-01-26 04:00:11 +0000718 eval.end(CGF);
Mike Stump4a3999f2009-09-09 13:00:44 +0000719
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000720 // Create a PHI node for the real part.
Jay Foad20c0f022011-03-30 11:28:58 +0000721 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r");
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000722 RealPN->addIncoming(LHS.first, LHSBlock);
723 RealPN->addIncoming(RHS.first, RHSBlock);
724
725 // Create a PHI node for the imaginary part.
Jay Foad20c0f022011-03-30 11:28:58 +0000726 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i");
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000727 ImagPN->addIncoming(LHS.second, LHSBlock);
728 ImagPN->addIncoming(RHS.second, RHSBlock);
Mike Stump4a3999f2009-09-09 13:00:44 +0000729
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000730 return ComplexPairTy(RealPN, ImagPN);
731}
732
Chris Lattnerdb0d60d2007-08-24 02:18:47 +0000733ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) {
Eli Friedmane0a5b8b2009-03-04 05:52:32 +0000734 return Visit(E->getChosenSubExpr(CGF.getContext()));
Chris Lattnerdb0d60d2007-08-24 02:18:47 +0000735}
736
Eli Friedmandd7406e2008-05-13 23:11:35 +0000737ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
Mike Stumpdf0fe272009-05-29 15:46:01 +0000738 bool Ignore = TestAndClearIgnoreReal();
739 (void)Ignore;
740 assert (Ignore == false && "init list ignored");
741 Ignore = TestAndClearIgnoreImag();
742 (void)Ignore;
743 assert (Ignore == false && "init list ignored");
Eli Friedman6b9c41e2011-09-19 23:17:44 +0000744
745 if (E->getNumInits() == 2) {
746 llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0));
747 llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1));
748 return ComplexPairTy(Real, Imag);
749 } else if (E->getNumInits() == 1) {
Eli Friedmandd7406e2008-05-13 23:11:35 +0000750 return Visit(E->getInit(0));
Eli Friedman6b9c41e2011-09-19 23:17:44 +0000751 }
Eli Friedmandd7406e2008-05-13 23:11:35 +0000752
753 // Empty init list intializes to null
Eli Friedman6b9c41e2011-09-19 23:17:44 +0000754 assert(E->getNumInits() == 0 && "Unexpected number of inits");
John McCall9dd450b2009-09-21 23:43:11 +0000755 QualType Ty = E->getType()->getAs<ComplexType>()->getElementType();
Chris Lattner2192fe52011-07-18 04:24:23 +0000756 llvm::Type* LTy = CGF.ConvertType(Ty);
Owen Anderson0b75f232009-07-31 20:28:54 +0000757 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
Eli Friedmandd7406e2008-05-13 23:11:35 +0000758 return ComplexPairTy(zeroConstant, zeroConstant);
759}
760
Daniel Dunbar00079612009-02-10 03:03:30 +0000761ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
Daniel Dunbare9fcadd22009-02-11 22:25:55 +0000762 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr());
Daniel Dunbar00079612009-02-10 03:03:30 +0000763 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType());
764
765 if (!ArgPtr) {
766 CGF.ErrorUnsupported(E, "complex va_arg expression");
Chris Lattner2192fe52011-07-18 04:24:23 +0000767 llvm::Type *EltTy =
John McCall9dd450b2009-09-21 23:43:11 +0000768 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType());
Daniel Dunbar00079612009-02-10 03:03:30 +0000769 llvm::Value *U = llvm::UndefValue::get(EltTy);
770 return ComplexPairTy(U, U);
771 }
772
773 // FIXME Volatility.
774 return EmitLoadOfComplex(ArgPtr, false);
775}
776
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000777//===----------------------------------------------------------------------===//
778// Entry Point into this File
779//===----------------------------------------------------------------------===//
780
781/// EmitComplexExpr - Emit the computation of the specified expression of
782/// complex type, ignoring the result.
Mike Stumpdf0fe272009-05-29 15:46:01 +0000783ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal,
John McCall07bb1962010-11-16 10:08:07 +0000784 bool IgnoreImag) {
Chris Lattnerf3bc75a2008-04-04 16:54:41 +0000785 assert(E && E->getType()->isAnyComplexType() &&
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000786 "Invalid complex expression to emit");
Mike Stump4a3999f2009-09-09 13:00:44 +0000787
John McCall07bb1962010-11-16 10:08:07 +0000788 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag)
Mike Stumpdf0fe272009-05-29 15:46:01 +0000789 .Visit(const_cast<Expr*>(E));
Chris Lattnercbfc73b2007-08-21 05:54:00 +0000790}
791
Chris Lattner08b15df2007-08-23 23:43:33 +0000792/// EmitComplexExprIntoAddr - Emit the computation of the specified expression
793/// of complex type, storing into the specified Value*.
794void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E,
Chris Lattnerb84bb952007-08-26 16:22:13 +0000795 llvm::Value *DestAddr,
796 bool DestIsVolatile) {
Chris Lattnerf3bc75a2008-04-04 16:54:41 +0000797 assert(E && E->getType()->isAnyComplexType() &&
Chris Lattner08b15df2007-08-23 23:43:33 +0000798 "Invalid complex expression to emit");
799 ComplexExprEmitter Emitter(*this);
800 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E));
Chris Lattnerb84bb952007-08-26 16:22:13 +0000801 Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile);
Chris Lattner08b15df2007-08-23 23:43:33 +0000802}
Chris Lattner4647a212007-08-31 22:49:20 +0000803
Daniel Dunbar4b8c6db2008-08-30 05:35:15 +0000804/// StoreComplexToAddr - Store a complex number into the specified address.
805void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V,
806 llvm::Value *DestAddr,
807 bool DestIsVolatile) {
808 ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile);
809}
810
Chris Lattner4647a212007-08-31 22:49:20 +0000811/// LoadComplexFromAddr - Load a complex number from the specified address.
Mike Stump4a3999f2009-09-09 13:00:44 +0000812ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr,
Chris Lattner4647a212007-08-31 22:49:20 +0000813 bool SrcIsVolatile) {
814 return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile);
815}
John McCall4f29b492010-11-16 23:07:28 +0000816
817LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) {
John McCalla2342eb2010-12-05 02:00:02 +0000818 assert(E->getOpcode() == BO_Assign);
John McCall4f29b492010-11-16 23:07:28 +0000819 ComplexPairTy Val; // ignored
John McCalla2342eb2010-12-05 02:00:02 +0000820 return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val);
821}
John McCall4f29b492010-11-16 23:07:28 +0000822
John McCalla2342eb2010-12-05 02:00:02 +0000823LValue CodeGenFunction::
824EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) {
John McCall4f29b492010-11-16 23:07:28 +0000825 ComplexPairTy(ComplexExprEmitter::*Op)(const ComplexExprEmitter::BinOpInfo &);
John McCall4f29b492010-11-16 23:07:28 +0000826 switch (E->getOpcode()) {
John McCall4f29b492010-11-16 23:07:28 +0000827 case BO_MulAssign: Op = &ComplexExprEmitter::EmitBinMul; break;
828 case BO_DivAssign: Op = &ComplexExprEmitter::EmitBinDiv; break;
829 case BO_SubAssign: Op = &ComplexExprEmitter::EmitBinSub; break;
830 case BO_AddAssign: Op = &ComplexExprEmitter::EmitBinAdd; break;
831
832 default:
833 llvm_unreachable("unexpected complex compound assignment");
834 Op = 0;
835 }
836
John McCalla2342eb2010-12-05 02:00:02 +0000837 ComplexPairTy Val; // ignored
838 return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
John McCall4f29b492010-11-16 23:07:28 +0000839}