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