1 //===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
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"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/StmtVisitor.h"
18 #include "llvm/Constants.h"
19 #include "llvm/Function.h"
20 #include "llvm/ADT/SmallString.h"
21 using namespace clang;
22 using namespace CodeGen;
23 
24 //===----------------------------------------------------------------------===//
25 //                        Complex Expression Emitter
26 //===----------------------------------------------------------------------===//
27 
28 typedef CodeGenFunction::ComplexPairTy ComplexPairTy;
29 
30 namespace  {
31 class ComplexExprEmitter
32   : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> {
33   CodeGenFunction &CGF;
34   CGBuilderTy &Builder;
35   // True is we should ignore the value of a
36   bool IgnoreReal;
37   bool IgnoreImag;
38 public:
39   ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false)
40     : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) {
41   }
42 
43 
44   //===--------------------------------------------------------------------===//
45   //                               Utilities
46   //===--------------------------------------------------------------------===//
47 
48   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   }
58 
59   /// 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.
62   ComplexPairTy EmitLoadOfLValue(const Expr *E) {
63     return EmitLoadOfLValue(CGF.EmitLValue(E));
64   }
65 
66   ComplexPairTy EmitLoadOfLValue(LValue LV) {
67     if (LV.isSimple())
68       return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified());
69 
70     assert(LV.isPropertyRef() && "Unknown LValue type!");
71     return CGF.EmitLoadOfPropertyRefLValue(LV).getComplexVal();
72   }
73 
74   /// EmitLoadOfComplex - Given a pointer to a complex value, emit code to load
75   /// the real and imaginary pieces.
76   ComplexPairTy EmitLoadOfComplex(llvm::Value *SrcPtr, bool isVolatile);
77 
78   /// 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 
88   /// EmitStoreOfComplex - Store the specified real/imag parts into the
89   /// specified value pointer.
90   void EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *ResPtr, bool isVol);
91 
92   /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
93   ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType,
94                                          QualType DestType);
95 
96   //===--------------------------------------------------------------------===//
97   //                            Visitor Methods
98   //===--------------------------------------------------------------------===//
99 
100   ComplexPairTy Visit(Expr *E) {
101     return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E);
102   }
103 
104   ComplexPairTy VisitStmt(Stmt *S) {
105     S->dump(CGF.getContext().getSourceManager());
106     llvm_unreachable("Stmt can't have complex result type!");
107   }
108   ComplexPairTy VisitExpr(Expr *S);
109   ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
110   ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
111     return Visit(GE->getResultExpr());
112   }
113   ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL);
114   ComplexPairTy
115   VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
116     return Visit(PE->getReplacement());
117   }
118 
119   // l-values.
120   ComplexPairTy VisitDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); }
121   ComplexPairTy VisitBlockDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); }
122   ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
123     return EmitLoadOfLValue(E);
124   }
125   ComplexPairTy VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
126     assert(E->getObjectKind() == OK_Ordinary);
127     return EmitLoadOfLValue(E);
128   }
129   ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) {
130     return CGF.EmitObjCMessageExpr(E).getComplexVal();
131   }
132   ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); }
133   ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); }
134   ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) {
135     if (E->isGLValue())
136       return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E));
137     return CGF.getOpaqueRValueMapping(E).getComplexVal();
138   }
139 
140   ComplexPairTy VisitPseudoObjectExpr(PseudoObjectExpr *E) {
141     return CGF.EmitPseudoObjectRValue(E).getComplexVal();
142   }
143 
144   // FIXME: CompoundLiteralExpr
145 
146   ComplexPairTy EmitCast(CastExpr::CastKind CK, Expr *Op, QualType DestTy);
147   ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) {
148     // Unlike for scalars, we don't have to worry about function->ptr demotion
149     // here.
150     return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
151   }
152   ComplexPairTy VisitCastExpr(CastExpr *E) {
153     return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
154   }
155   ComplexPairTy VisitCallExpr(const CallExpr *E);
156   ComplexPairTy VisitStmtExpr(const StmtExpr *E);
157 
158   // Operators.
159   ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E,
160                                    bool isInc, bool isPre) {
161     LValue LV = CGF.EmitLValue(E->getSubExpr());
162     return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre);
163   }
164   ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) {
165     return VisitPrePostIncDec(E, false, false);
166   }
167   ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) {
168     return VisitPrePostIncDec(E, true, false);
169   }
170   ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) {
171     return VisitPrePostIncDec(E, false, true);
172   }
173   ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) {
174     return VisitPrePostIncDec(E, true, true);
175   }
176   ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
177   ComplexPairTy VisitUnaryPlus     (const UnaryOperator *E) {
178     TestAndClearIgnoreReal();
179     TestAndClearIgnoreImag();
180     return Visit(E->getSubExpr());
181   }
182   ComplexPairTy VisitUnaryMinus    (const UnaryOperator *E);
183   ComplexPairTy VisitUnaryNot      (const UnaryOperator *E);
184   // LNot,Real,Imag never return complex.
185   ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) {
186     return Visit(E->getSubExpr());
187   }
188   ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
189     return Visit(DAE->getExpr());
190   }
191   ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) {
192     return CGF.EmitExprWithCleanups(E).getComplexVal();
193   }
194   ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
195     assert(E->getType()->isAnyComplexType() && "Expected complex type!");
196     QualType Elem = E->getType()->getAs<ComplexType>()->getElementType();
197     llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem));
198     return ComplexPairTy(Null, Null);
199   }
200   ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
201     assert(E->getType()->isAnyComplexType() && "Expected complex type!");
202     QualType Elem = E->getType()->getAs<ComplexType>()->getElementType();
203     llvm::Constant *Null =
204                        llvm::Constant::getNullValue(CGF.ConvertType(Elem));
205     return ComplexPairTy(Null, Null);
206   }
207 
208   struct BinOpInfo {
209     ComplexPairTy LHS;
210     ComplexPairTy RHS;
211     QualType Ty;  // Computation Type.
212   };
213 
214   BinOpInfo EmitBinOps(const BinaryOperator *E);
215   LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
216                                   ComplexPairTy (ComplexExprEmitter::*Func)
217                                   (const BinOpInfo &),
218                                   ComplexPairTy &Val);
219   ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E,
220                                    ComplexPairTy (ComplexExprEmitter::*Func)
221                                    (const BinOpInfo &));
222 
223   ComplexPairTy EmitBinAdd(const BinOpInfo &Op);
224   ComplexPairTy EmitBinSub(const BinOpInfo &Op);
225   ComplexPairTy EmitBinMul(const BinOpInfo &Op);
226   ComplexPairTy EmitBinDiv(const BinOpInfo &Op);
227 
228   ComplexPairTy VisitBinAdd(const BinaryOperator *E) {
229     return EmitBinAdd(EmitBinOps(E));
230   }
231   ComplexPairTy VisitBinSub(const BinaryOperator *E) {
232     return EmitBinSub(EmitBinOps(E));
233   }
234   ComplexPairTy VisitBinMul(const BinaryOperator *E) {
235     return EmitBinMul(EmitBinOps(E));
236   }
237   ComplexPairTy VisitBinDiv(const BinaryOperator *E) {
238     return EmitBinDiv(EmitBinOps(E));
239   }
240 
241   // Compound assignments.
242   ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) {
243     return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd);
244   }
245   ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) {
246     return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub);
247   }
248   ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) {
249     return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul);
250   }
251   ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) {
252     return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv);
253   }
254 
255   // GCC rejects rem/and/or/xor for integer complex.
256   // Logical and/or always return int, never complex.
257 
258   // No comparisons produce a complex result.
259 
260   LValue EmitBinAssignLValue(const BinaryOperator *E,
261                              ComplexPairTy &Val);
262   ComplexPairTy VisitBinAssign     (const BinaryOperator *E);
263   ComplexPairTy VisitBinComma      (const BinaryOperator *E);
264 
265 
266   ComplexPairTy
267   VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
268   ComplexPairTy VisitChooseExpr(ChooseExpr *CE);
269 
270   ComplexPairTy VisitInitListExpr(InitListExpr *E);
271 
272   ComplexPairTy VisitVAArgExpr(VAArgExpr *E);
273 
274   ComplexPairTy VisitAtomicExpr(AtomicExpr *E) {
275     return CGF.EmitAtomicExpr(E).getComplexVal();
276   }
277 };
278 }  // end anonymous namespace.
279 
280 //===----------------------------------------------------------------------===//
281 //                                Utilities
282 //===----------------------------------------------------------------------===//
283 
284 /// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to
285 /// load the real and imaginary pieces, returning them as Real/Imag.
286 ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr,
287                                                     bool isVolatile) {
288   llvm::Value *Real=0, *Imag=0;
289 
290   if (!IgnoreReal || isVolatile) {
291     llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0,
292                                                  SrcPtr->getName() + ".realp");
293     Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr->getName() + ".real");
294   }
295 
296   if (!IgnoreImag || isVolatile) {
297     llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1,
298                                                  SrcPtr->getName() + ".imagp");
299     Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr->getName() + ".imag");
300   }
301   return ComplexPairTy(Real, Imag);
302 }
303 
304 /// EmitStoreOfComplex - Store the specified real/imag parts into the
305 /// specified value pointer.
306 void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *Ptr,
307                                             bool isVolatile) {
308   llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real");
309   llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag");
310 
311   Builder.CreateStore(Val.first, RealPtr, isVolatile);
312   Builder.CreateStore(Val.second, ImagPtr, isVolatile);
313 }
314 
315 
316 
317 //===----------------------------------------------------------------------===//
318 //                            Visitor Methods
319 //===----------------------------------------------------------------------===//
320 
321 ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
322   CGF.ErrorUnsupported(E, "complex expression");
323   llvm::Type *EltTy =
324   CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType());
325   llvm::Value *U = llvm::UndefValue::get(EltTy);
326   return ComplexPairTy(U, U);
327 }
328 
329 ComplexPairTy ComplexExprEmitter::
330 VisitImaginaryLiteral(const ImaginaryLiteral *IL) {
331   llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr());
332   return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag);
333 }
334 
335 
336 ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
337   if (E->getCallReturnType()->isReferenceType())
338     return EmitLoadOfLValue(E);
339 
340   return CGF.EmitCallExpr(E).getComplexVal();
341 }
342 
343 ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) {
344   CodeGenFunction::StmtExprEvaluation eval(CGF);
345   return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal();
346 }
347 
348 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
349 ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val,
350                                                            QualType SrcType,
351                                                            QualType DestType) {
352   // Get the src/dest element type.
353   SrcType = SrcType->getAs<ComplexType>()->getElementType();
354   DestType = DestType->getAs<ComplexType>()->getElementType();
355 
356   // C99 6.3.1.6: When a value of complex type is converted to another
357   // complex type, both the real and imaginary parts follow the conversion
358   // rules for the corresponding real types.
359   Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType);
360   Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType);
361   return Val;
362 }
363 
364 ComplexPairTy ComplexExprEmitter::EmitCast(CastExpr::CastKind CK, Expr *Op,
365                                            QualType DestTy) {
366   switch (CK) {
367   case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!");
368 
369   case CK_GetObjCProperty: {
370     LValue LV = CGF.EmitObjCPropertyRefLValue(Op->getObjCProperty());
371     assert(LV.isPropertyRef() && "Unknown LValue type!");
372     return CGF.EmitLoadOfPropertyRefLValue(LV).getComplexVal();
373   }
374 
375   case CK_NoOp:
376   case CK_LValueToRValue:
377   case CK_UserDefinedConversion:
378     return Visit(Op);
379 
380   case CK_LValueBitCast: {
381     llvm::Value *V = CGF.EmitLValue(Op).getAddress();
382     V = Builder.CreateBitCast(V,
383                     CGF.ConvertType(CGF.getContext().getPointerType(DestTy)));
384     // FIXME: Are the qualifiers correct here?
385     return EmitLoadOfComplex(V, DestTy.isVolatileQualified());
386   }
387 
388   case CK_BitCast:
389   case CK_BaseToDerived:
390   case CK_DerivedToBase:
391   case CK_UncheckedDerivedToBase:
392   case CK_Dynamic:
393   case CK_ToUnion:
394   case CK_ArrayToPointerDecay:
395   case CK_FunctionToPointerDecay:
396   case CK_NullToPointer:
397   case CK_NullToMemberPointer:
398   case CK_BaseToDerivedMemberPointer:
399   case CK_DerivedToBaseMemberPointer:
400   case CK_MemberPointerToBoolean:
401   case CK_ConstructorConversion:
402   case CK_IntegralToPointer:
403   case CK_PointerToIntegral:
404   case CK_PointerToBoolean:
405   case CK_ToVoid:
406   case CK_VectorSplat:
407   case CK_IntegralCast:
408   case CK_IntegralToBoolean:
409   case CK_IntegralToFloating:
410   case CK_FloatingToIntegral:
411   case CK_FloatingToBoolean:
412   case CK_FloatingCast:
413   case CK_CPointerToObjCPointerCast:
414   case CK_BlockPointerToObjCPointerCast:
415   case CK_AnyPointerToBlockPointerCast:
416   case CK_ObjCObjectLValueCast:
417   case CK_FloatingComplexToReal:
418   case CK_FloatingComplexToBoolean:
419   case CK_IntegralComplexToReal:
420   case CK_IntegralComplexToBoolean:
421   case CK_ARCProduceObject:
422   case CK_ARCConsumeObject:
423   case CK_ARCReclaimReturnedObject:
424   case CK_ARCExtendBlockObject:
425     llvm_unreachable("invalid cast kind for complex value");
426 
427   case CK_FloatingRealToComplex:
428   case CK_IntegralRealToComplex: {
429     llvm::Value *Elt = CGF.EmitScalarExpr(Op);
430 
431     // Convert the input element to the element type of the complex.
432     DestTy = DestTy->getAs<ComplexType>()->getElementType();
433     Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy);
434 
435     // Return (realval, 0).
436     return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType()));
437   }
438 
439   case CK_FloatingComplexCast:
440   case CK_FloatingComplexToIntegralComplex:
441   case CK_IntegralComplexCast:
442   case CK_IntegralComplexToFloatingComplex:
443     return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy);
444   }
445 
446   llvm_unreachable("unknown cast resulting in complex value");
447 }
448 
449 ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
450   TestAndClearIgnoreReal();
451   TestAndClearIgnoreImag();
452   ComplexPairTy Op = Visit(E->getSubExpr());
453 
454   llvm::Value *ResR, *ResI;
455   if (Op.first->getType()->isFloatingPointTy()) {
456     ResR = Builder.CreateFNeg(Op.first,  "neg.r");
457     ResI = Builder.CreateFNeg(Op.second, "neg.i");
458   } else {
459     ResR = Builder.CreateNeg(Op.first,  "neg.r");
460     ResI = Builder.CreateNeg(Op.second, "neg.i");
461   }
462   return ComplexPairTy(ResR, ResI);
463 }
464 
465 ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
466   TestAndClearIgnoreReal();
467   TestAndClearIgnoreImag();
468   // ~(a+ib) = a + i*-b
469   ComplexPairTy Op = Visit(E->getSubExpr());
470   llvm::Value *ResI;
471   if (Op.second->getType()->isFloatingPointTy())
472     ResI = Builder.CreateFNeg(Op.second, "conj.i");
473   else
474     ResI = Builder.CreateNeg(Op.second, "conj.i");
475 
476   return ComplexPairTy(Op.first, ResI);
477 }
478 
479 ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) {
480   llvm::Value *ResR, *ResI;
481 
482   if (Op.LHS.first->getType()->isFloatingPointTy()) {
483     ResR = Builder.CreateFAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
484     ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i");
485   } else {
486     ResR = Builder.CreateAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
487     ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i");
488   }
489   return ComplexPairTy(ResR, ResI);
490 }
491 
492 ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) {
493   llvm::Value *ResR, *ResI;
494   if (Op.LHS.first->getType()->isFloatingPointTy()) {
495     ResR = Builder.CreateFSub(Op.LHS.first,  Op.RHS.first,  "sub.r");
496     ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i");
497   } else {
498     ResR = Builder.CreateSub(Op.LHS.first,  Op.RHS.first,  "sub.r");
499     ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i");
500   }
501   return ComplexPairTy(ResR, ResI);
502 }
503 
504 
505 ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) {
506   using llvm::Value;
507   Value *ResR, *ResI;
508 
509   if (Op.LHS.first->getType()->isFloatingPointTy()) {
510     Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl");
511     Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr");
512     ResR  = Builder.CreateFSub(ResRl, ResRr, "mul.r");
513 
514     Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il");
515     Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir");
516     ResI  = Builder.CreateFAdd(ResIl, ResIr, "mul.i");
517   } else {
518     Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl");
519     Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr");
520     ResR  = Builder.CreateSub(ResRl, ResRr, "mul.r");
521 
522     Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il");
523     Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir");
524     ResI  = Builder.CreateAdd(ResIl, ResIr, "mul.i");
525   }
526   return ComplexPairTy(ResR, ResI);
527 }
528 
529 ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) {
530   llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
531   llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
532 
533 
534   llvm::Value *DSTr, *DSTi;
535   if (Op.LHS.first->getType()->isFloatingPointTy()) {
536     // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
537     llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr); // a*c
538     llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi); // b*d
539     llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2); // ac+bd
540 
541     llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr); // c*c
542     llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi); // d*d
543     llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5); // cc+dd
544 
545     llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr); // b*c
546     llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi); // a*d
547     llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8); // bc-ad
548 
549     DSTr = Builder.CreateFDiv(Tmp3, Tmp6);
550     DSTi = Builder.CreateFDiv(Tmp9, Tmp6);
551   } else {
552     // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
553     llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c
554     llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d
555     llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd
556 
557     llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c
558     llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d
559     llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd
560 
561     llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c
562     llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d
563     llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad
564 
565     if (Op.Ty->getAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) {
566       DSTr = Builder.CreateUDiv(Tmp3, Tmp6);
567       DSTi = Builder.CreateUDiv(Tmp9, Tmp6);
568     } else {
569       DSTr = Builder.CreateSDiv(Tmp3, Tmp6);
570       DSTi = Builder.CreateSDiv(Tmp9, Tmp6);
571     }
572   }
573 
574   return ComplexPairTy(DSTr, DSTi);
575 }
576 
577 ComplexExprEmitter::BinOpInfo
578 ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) {
579   TestAndClearIgnoreReal();
580   TestAndClearIgnoreImag();
581   BinOpInfo Ops;
582   Ops.LHS = Visit(E->getLHS());
583   Ops.RHS = Visit(E->getRHS());
584   Ops.Ty = E->getType();
585   return Ops;
586 }
587 
588 
589 LValue ComplexExprEmitter::
590 EmitCompoundAssignLValue(const CompoundAssignOperator *E,
591           ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&),
592                          ComplexPairTy &Val) {
593   TestAndClearIgnoreReal();
594   TestAndClearIgnoreImag();
595   QualType LHSTy = E->getLHS()->getType();
596 
597   BinOpInfo OpInfo;
598 
599   // Load the RHS and LHS operands.
600   // __block variables need to have the rhs evaluated first, plus this should
601   // improve codegen a little.
602   OpInfo.Ty = E->getComputationResultType();
603 
604   // The RHS should have been converted to the computation type.
605   assert(OpInfo.Ty->isAnyComplexType());
606   assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty,
607                                                  E->getRHS()->getType()));
608   OpInfo.RHS = Visit(E->getRHS());
609 
610   LValue LHS = CGF.EmitLValue(E->getLHS());
611 
612   // Load from the l-value.
613   ComplexPairTy LHSComplexPair = EmitLoadOfLValue(LHS);
614 
615   OpInfo.LHS = EmitComplexToComplexCast(LHSComplexPair, LHSTy, OpInfo.Ty);
616 
617   // Expand the binary operator.
618   ComplexPairTy Result = (this->*Func)(OpInfo);
619 
620   // Truncate the result back to the LHS type.
621   Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy);
622   Val = Result;
623 
624   // Store the result value into the LHS lvalue.
625   EmitStoreThroughLValue(Result, LHS);
626 
627   return LHS;
628 }
629 
630 // Compound assignments.
631 ComplexPairTy ComplexExprEmitter::
632 EmitCompoundAssign(const CompoundAssignOperator *E,
633                    ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){
634   ComplexPairTy Val;
635   LValue LV = EmitCompoundAssignLValue(E, Func, Val);
636 
637   // The result of an assignment in C is the assigned r-value.
638   if (!CGF.getContext().getLangOptions().CPlusPlus)
639     return Val;
640 
641   // Objective-C property assignment never reloads the value following a store.
642   if (LV.isPropertyRef())
643     return Val;
644 
645   // If the lvalue is non-volatile, return the computed value of the assignment.
646   if (!LV.isVolatileQualified())
647     return Val;
648 
649   return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified());
650 }
651 
652 LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E,
653                                                ComplexPairTy &Val) {
654   assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
655                                                  E->getRHS()->getType()) &&
656          "Invalid assignment");
657   TestAndClearIgnoreReal();
658   TestAndClearIgnoreImag();
659 
660   // Emit the RHS.  __block variables need the RHS evaluated first.
661   Val = Visit(E->getRHS());
662 
663   // Compute the address to store into.
664   LValue LHS = CGF.EmitLValue(E->getLHS());
665 
666   // Store the result value into the LHS lvalue.
667   EmitStoreThroughLValue(Val, LHS);
668 
669   return LHS;
670 }
671 
672 ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
673   ComplexPairTy Val;
674   LValue LV = EmitBinAssignLValue(E, Val);
675 
676   // The result of an assignment in C is the assigned r-value.
677   if (!CGF.getContext().getLangOptions().CPlusPlus)
678     return Val;
679 
680   // Objective-C property assignment never reloads the value following a store.
681   if (LV.isPropertyRef())
682     return Val;
683 
684   // If the lvalue is non-volatile, return the computed value of the assignment.
685   if (!LV.isVolatileQualified())
686     return Val;
687 
688   return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified());
689 }
690 
691 ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) {
692   CGF.EmitIgnoredExpr(E->getLHS());
693   return Visit(E->getRHS());
694 }
695 
696 ComplexPairTy ComplexExprEmitter::
697 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
698   TestAndClearIgnoreReal();
699   TestAndClearIgnoreImag();
700   llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
701   llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
702   llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
703 
704   // Bind the common expression if necessary.
705   CodeGenFunction::OpaqueValueMapping binding(CGF, E);
706 
707   CodeGenFunction::ConditionalEvaluation eval(CGF);
708   CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
709 
710   eval.begin(CGF);
711   CGF.EmitBlock(LHSBlock);
712   ComplexPairTy LHS = Visit(E->getTrueExpr());
713   LHSBlock = Builder.GetInsertBlock();
714   CGF.EmitBranch(ContBlock);
715   eval.end(CGF);
716 
717   eval.begin(CGF);
718   CGF.EmitBlock(RHSBlock);
719   ComplexPairTy RHS = Visit(E->getFalseExpr());
720   RHSBlock = Builder.GetInsertBlock();
721   CGF.EmitBlock(ContBlock);
722   eval.end(CGF);
723 
724   // Create a PHI node for the real part.
725   llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r");
726   RealPN->addIncoming(LHS.first, LHSBlock);
727   RealPN->addIncoming(RHS.first, RHSBlock);
728 
729   // Create a PHI node for the imaginary part.
730   llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i");
731   ImagPN->addIncoming(LHS.second, LHSBlock);
732   ImagPN->addIncoming(RHS.second, RHSBlock);
733 
734   return ComplexPairTy(RealPN, ImagPN);
735 }
736 
737 ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) {
738   return Visit(E->getChosenSubExpr(CGF.getContext()));
739 }
740 
741 ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
742     bool Ignore = TestAndClearIgnoreReal();
743     (void)Ignore;
744     assert (Ignore == false && "init list ignored");
745     Ignore = TestAndClearIgnoreImag();
746     (void)Ignore;
747     assert (Ignore == false && "init list ignored");
748 
749   if (E->getNumInits() == 2) {
750     llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0));
751     llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1));
752     return ComplexPairTy(Real, Imag);
753   } else if (E->getNumInits() == 1) {
754     return Visit(E->getInit(0));
755   }
756 
757   // Empty init list intializes to null
758   assert(E->getNumInits() == 0 && "Unexpected number of inits");
759   QualType Ty = E->getType()->getAs<ComplexType>()->getElementType();
760   llvm::Type* LTy = CGF.ConvertType(Ty);
761   llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
762   return ComplexPairTy(zeroConstant, zeroConstant);
763 }
764 
765 ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
766   llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr());
767   llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType());
768 
769   if (!ArgPtr) {
770     CGF.ErrorUnsupported(E, "complex va_arg expression");
771     llvm::Type *EltTy =
772       CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType());
773     llvm::Value *U = llvm::UndefValue::get(EltTy);
774     return ComplexPairTy(U, U);
775   }
776 
777   // FIXME Volatility.
778   return EmitLoadOfComplex(ArgPtr, false);
779 }
780 
781 //===----------------------------------------------------------------------===//
782 //                         Entry Point into this File
783 //===----------------------------------------------------------------------===//
784 
785 /// EmitComplexExpr - Emit the computation of the specified expression of
786 /// complex type, ignoring the result.
787 ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal,
788                                                bool IgnoreImag) {
789   assert(E && E->getType()->isAnyComplexType() &&
790          "Invalid complex expression to emit");
791 
792   return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag)
793     .Visit(const_cast<Expr*>(E));
794 }
795 
796 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
797 /// of complex type, storing into the specified Value*.
798 void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E,
799                                               llvm::Value *DestAddr,
800                                               bool DestIsVolatile) {
801   assert(E && E->getType()->isAnyComplexType() &&
802          "Invalid complex expression to emit");
803   ComplexExprEmitter Emitter(*this);
804   ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E));
805   Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile);
806 }
807 
808 /// StoreComplexToAddr - Store a complex number into the specified address.
809 void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V,
810                                          llvm::Value *DestAddr,
811                                          bool DestIsVolatile) {
812   ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile);
813 }
814 
815 /// LoadComplexFromAddr - Load a complex number from the specified address.
816 ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr,
817                                                    bool SrcIsVolatile) {
818   return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile);
819 }
820 
821 LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) {
822   assert(E->getOpcode() == BO_Assign);
823   ComplexPairTy Val; // ignored
824   return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val);
825 }
826 
827 LValue CodeGenFunction::
828 EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) {
829   ComplexPairTy(ComplexExprEmitter::*Op)(const ComplexExprEmitter::BinOpInfo &);
830   switch (E->getOpcode()) {
831   case BO_MulAssign: Op = &ComplexExprEmitter::EmitBinMul; break;
832   case BO_DivAssign: Op = &ComplexExprEmitter::EmitBinDiv; break;
833   case BO_SubAssign: Op = &ComplexExprEmitter::EmitBinSub; break;
834   case BO_AddAssign: Op = &ComplexExprEmitter::EmitBinAdd; break;
835 
836   default:
837     llvm_unreachable("unexpected complex compound assignment");
838     Op = 0;
839   }
840 
841   ComplexPairTy Val; // ignored
842   return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
843 }
844