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