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