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