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