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