CGExprComplex.cpp revision 8e274bd14bcca8466542477844b88e90e90cde1a 
1//===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Expr nodes with complex types as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
15#include "CodeGenModule.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/StmtVisitor.h"
18#include "llvm/Constants.h"
19#include "llvm/Function.h"
20#include "llvm/ADT/SmallString.h"
21using namespace clang;
22using namespace CodeGen;
23
24//===----------------------------------------------------------------------===//
25//                        Complex Expression Emitter
26//===----------------------------------------------------------------------===//
27
28typedef CodeGenFunction::ComplexPairTy ComplexPairTy;
29
30namespace  {
31class ComplexExprEmitter
32  : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> {
33  CodeGenFunction &CGF;
34  CGBuilderTy &Builder;
35  // True is we should ignore the value of a
36  bool IgnoreReal;
37  bool IgnoreImag;
38  // True if we should ignore the value of a=b
39  bool IgnoreRealAssign;
40  bool IgnoreImagAssign;
41public:
42  ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false,
43                     bool irn=false, bool iin=false)
44    : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii),
45    IgnoreRealAssign(irn), IgnoreImagAssign(iin) {
46  }
47
48
49  //===--------------------------------------------------------------------===//
50  //                               Utilities
51  //===--------------------------------------------------------------------===//
52
53  bool TestAndClearIgnoreReal() {
54    bool I = IgnoreReal;
55    IgnoreReal = false;
56    return I;
57  }
58  bool TestAndClearIgnoreImag() {
59    bool I = IgnoreImag;
60    IgnoreImag = false;
61    return I;
62  }
63  bool TestAndClearIgnoreRealAssign() {
64    bool I = IgnoreRealAssign;
65    IgnoreRealAssign = false;
66    return I;
67  }
68  bool TestAndClearIgnoreImagAssign() {
69    bool I = IgnoreImagAssign;
70    IgnoreImagAssign = false;
71    return I;
72  }
73
74  /// EmitLoadOfLValue - Given an expression with complex type that represents a
75  /// value l-value, this method emits the address of the l-value, then loads
76  /// and returns the result.
77  ComplexPairTy EmitLoadOfLValue(const Expr *E) {
78    LValue LV = CGF.EmitLValue(E);
79    if (LV.isSimple())
80      return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified());
81
82    if (LV.isPropertyRef())
83      return CGF.EmitObjCPropertyGet(LV.getPropertyRefExpr()).getComplexVal();
84
85    assert(LV.isKVCRef() && "Unknown LValue type!");
86    return CGF.EmitObjCPropertyGet(LV.getKVCRefExpr()).getComplexVal();
87  }
88
89  /// EmitLoadOfComplex - Given a pointer to a complex value, emit code to load
90  /// the real and imaginary pieces.
91  ComplexPairTy EmitLoadOfComplex(llvm::Value *SrcPtr, bool isVolatile);
92
93  /// EmitStoreOfComplex - Store the specified real/imag parts into the
94  /// specified value pointer.
95  void EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *ResPtr, bool isVol);
96
97  /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
98  ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType,
99                                         QualType DestType);
100
101  //===--------------------------------------------------------------------===//
102  //                            Visitor Methods
103  //===--------------------------------------------------------------------===//
104
105  ComplexPairTy VisitStmt(Stmt *S) {
106    S->dump(CGF.getContext().getSourceManager());
107    assert(0 && "Stmt can't have complex result type!");
108    return ComplexPairTy();
109  }
110  ComplexPairTy VisitExpr(Expr *S);
111  ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
112  ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL);
113
114  // l-values.
115  ComplexPairTy VisitDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); }
116  ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
117    return EmitLoadOfLValue(E);
118  }
119  ComplexPairTy VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
120    return EmitLoadOfLValue(E);
121  }
122  ComplexPairTy VisitObjCImplicitSetterGetterRefExpr(
123                               ObjCImplicitSetterGetterRefExpr *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
132  // FIXME: CompoundLiteralExpr
133
134  ComplexPairTy EmitCast(Expr *Op, QualType DestTy);
135  ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) {
136    // Unlike for scalars, we don't have to worry about function->ptr demotion
137    // here.
138    return EmitCast(E->getSubExpr(), E->getType());
139  }
140  ComplexPairTy VisitCastExpr(CastExpr *E) {
141    return EmitCast(E->getSubExpr(), E->getType());
142  }
143  ComplexPairTy VisitCallExpr(const CallExpr *E);
144  ComplexPairTy VisitStmtExpr(const StmtExpr *E);
145
146  // Operators.
147  ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E,
148                                   bool isInc, bool isPre);
149  ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) {
150    return VisitPrePostIncDec(E, false, false);
151  }
152  ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) {
153    return VisitPrePostIncDec(E, true, false);
154  }
155  ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) {
156    return VisitPrePostIncDec(E, false, true);
157  }
158  ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) {
159    return VisitPrePostIncDec(E, true, true);
160  }
161  ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
162  ComplexPairTy VisitUnaryPlus     (const UnaryOperator *E) {
163    TestAndClearIgnoreReal();
164    TestAndClearIgnoreImag();
165    TestAndClearIgnoreRealAssign();
166    TestAndClearIgnoreImagAssign();
167    return Visit(E->getSubExpr());
168  }
169  ComplexPairTy VisitUnaryMinus    (const UnaryOperator *E);
170  ComplexPairTy VisitUnaryNot      (const UnaryOperator *E);
171  // LNot,Real,Imag never return complex.
172  ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) {
173    return Visit(E->getSubExpr());
174  }
175  ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
176    return Visit(DAE->getExpr());
177  }
178  ComplexPairTy VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) {
179    return CGF.EmitCXXExprWithTemporaries(E).getComplexVal();
180  }
181  ComplexPairTy VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) {
182    assert(E->getType()->isAnyComplexType() && "Expected complex type!");
183    QualType Elem = E->getType()->getAs<ComplexType>()->getElementType();
184    llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem));
185    return ComplexPairTy(Null, Null);
186  }
187  ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
188    assert(E->getType()->isAnyComplexType() && "Expected complex type!");
189    QualType Elem = E->getType()->getAs<ComplexType>()->getElementType();
190    llvm::Constant *Null =
191                       llvm::Constant::getNullValue(CGF.ConvertType(Elem));
192    return ComplexPairTy(Null, Null);
193  }
194
195  struct BinOpInfo {
196    ComplexPairTy LHS;
197    ComplexPairTy RHS;
198    QualType Ty;  // Computation Type.
199  };
200
201  BinOpInfo EmitBinOps(const BinaryOperator *E);
202  ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E,
203                                   ComplexPairTy (ComplexExprEmitter::*Func)
204                                   (const BinOpInfo &));
205
206  ComplexPairTy EmitBinAdd(const BinOpInfo &Op);
207  ComplexPairTy EmitBinSub(const BinOpInfo &Op);
208  ComplexPairTy EmitBinMul(const BinOpInfo &Op);
209  ComplexPairTy EmitBinDiv(const BinOpInfo &Op);
210
211  ComplexPairTy VisitBinMul(const BinaryOperator *E) {
212    return EmitBinMul(EmitBinOps(E));
213  }
214  ComplexPairTy VisitBinAdd(const BinaryOperator *E) {
215    return EmitBinAdd(EmitBinOps(E));
216  }
217  ComplexPairTy VisitBinSub(const BinaryOperator *E) {
218    return EmitBinSub(EmitBinOps(E));
219  }
220  ComplexPairTy VisitBinDiv(const BinaryOperator *E) {
221    return EmitBinDiv(EmitBinOps(E));
222  }
223
224  // Compound assignments.
225  ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) {
226    return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd);
227  }
228  ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) {
229    return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub);
230  }
231  ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) {
232    return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul);
233  }
234  ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) {
235    return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv);
236  }
237
238  // GCC rejects rem/and/or/xor for integer complex.
239  // Logical and/or always return int, never complex.
240
241  // No comparisons produce a complex result.
242  ComplexPairTy VisitBinAssign     (const BinaryOperator *E);
243  ComplexPairTy VisitBinComma      (const BinaryOperator *E);
244
245
246  ComplexPairTy VisitConditionalOperator(const ConditionalOperator *CO);
247  ComplexPairTy VisitChooseExpr(ChooseExpr *CE);
248
249  ComplexPairTy VisitInitListExpr(InitListExpr *E);
250
251  ComplexPairTy VisitVAArgExpr(VAArgExpr *E);
252};
253}  // end anonymous namespace.
254
255//===----------------------------------------------------------------------===//
256//                                Utilities
257//===----------------------------------------------------------------------===//
258
259/// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to
260/// load the real and imaginary pieces, returning them as Real/Imag.
261ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr,
262                                                    bool isVolatile) {
263  llvm::Value *Real=0, *Imag=0;
264
265  if (!IgnoreReal) {
266    llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0,
267                                                 SrcPtr->getName() + ".realp");
268    Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr->getName() + ".real");
269  }
270
271  if (!IgnoreImag) {
272    llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1,
273                                                 SrcPtr->getName() + ".imagp");
274    Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr->getName() + ".imag");
275  }
276  return ComplexPairTy(Real, Imag);
277}
278
279/// EmitStoreOfComplex - Store the specified real/imag parts into the
280/// specified value pointer.
281void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *Ptr,
282                                            bool isVolatile) {
283  llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real");
284  llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag");
285
286  Builder.CreateStore(Val.first, RealPtr, isVolatile);
287  Builder.CreateStore(Val.second, ImagPtr, isVolatile);
288}
289
290
291
292//===----------------------------------------------------------------------===//
293//                            Visitor Methods
294//===----------------------------------------------------------------------===//
295
296ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
297  CGF.ErrorUnsupported(E, "complex expression");
298  const llvm::Type *EltTy =
299    CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType());
300  llvm::Value *U = llvm::UndefValue::get(EltTy);
301  return ComplexPairTy(U, U);
302}
303
304ComplexPairTy ComplexExprEmitter::
305VisitImaginaryLiteral(const ImaginaryLiteral *IL) {
306  llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr());
307  return
308        ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag);
309}
310
311
312ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
313  if (E->getCallReturnType()->isReferenceType())
314    return EmitLoadOfLValue(E);
315
316  return CGF.EmitCallExpr(E).getComplexVal();
317}
318
319ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) {
320  return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal();
321}
322
323/// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
324ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val,
325                                                           QualType SrcType,
326                                                           QualType DestType) {
327  // Get the src/dest element type.
328  SrcType = SrcType->getAs<ComplexType>()->getElementType();
329  DestType = DestType->getAs<ComplexType>()->getElementType();
330
331  // C99 6.3.1.6: When a value of complex type is converted to another
332  // complex type, both the real and imaginary parts follow the conversion
333  // rules for the corresponding real types.
334  Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType);
335  Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType);
336  return Val;
337}
338
339ComplexPairTy ComplexExprEmitter::EmitCast(Expr *Op, QualType DestTy) {
340  // Two cases here: cast from (complex to complex) and (scalar to complex).
341  if (Op->getType()->isAnyComplexType())
342    return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy);
343
344  // C99 6.3.1.7: When a value of real type is converted to a complex type, the
345  // real part of the complex result value is determined by the rules of
346  // conversion to the corresponding real type and the imaginary part of the
347  // complex result value is a positive zero or an unsigned zero.
348  llvm::Value *Elt = CGF.EmitScalarExpr(Op);
349
350  // Convert the input element to the element type of the complex.
351  DestTy = DestTy->getAs<ComplexType>()->getElementType();
352  Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy);
353
354  // Return (realval, 0).
355  return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType()));
356}
357
358ComplexPairTy ComplexExprEmitter::VisitPrePostIncDec(const UnaryOperator *E,
359                                                     bool isInc, bool isPre) {
360  LValue LV = CGF.EmitLValue(E->getSubExpr());
361  ComplexPairTy InVal = EmitLoadOfComplex(LV.getAddress(),
362                                          LV.isVolatileQualified());
363
364  llvm::Value *NextVal;
365  if (isa<llvm::IntegerType>(InVal.first->getType())) {
366    uint64_t AmountVal = isInc ? 1 : -1;
367    NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true);
368
369    // Add the inc/dec to the real part.
370    NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
371  } else {
372    QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType();
373    llvm::APFloat FVal(CGF.getContext().getFloatTypeSemantics(ElemTy), 1);
374    if (!isInc)
375      FVal.changeSign();
376    NextVal = llvm::ConstantFP::get(CGF.getLLVMContext(), FVal);
377
378    // Add the inc/dec to the real part.
379    NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
380  }
381
382  ComplexPairTy IncVal(NextVal, InVal.second);
383
384  // Store the updated result through the lvalue.
385  EmitStoreOfComplex(IncVal, LV.getAddress(), LV.isVolatileQualified());
386
387  // If this is a postinc, return the value read from memory, otherwise use the
388  // updated value.
389  return isPre ? IncVal : InVal;
390}
391
392ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
393  TestAndClearIgnoreReal();
394  TestAndClearIgnoreImag();
395  TestAndClearIgnoreRealAssign();
396  TestAndClearIgnoreImagAssign();
397  ComplexPairTy Op = Visit(E->getSubExpr());
398
399  llvm::Value *ResR, *ResI;
400  if (Op.first->getType()->isFloatingPoint()) {
401    ResR = Builder.CreateFNeg(Op.first,  "neg.r");
402    ResI = Builder.CreateFNeg(Op.second, "neg.i");
403  } else {
404    ResR = Builder.CreateNeg(Op.first,  "neg.r");
405    ResI = Builder.CreateNeg(Op.second, "neg.i");
406  }
407  return ComplexPairTy(ResR, ResI);
408}
409
410ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
411  TestAndClearIgnoreReal();
412  TestAndClearIgnoreImag();
413  TestAndClearIgnoreRealAssign();
414  TestAndClearIgnoreImagAssign();
415  // ~(a+ib) = a + i*-b
416  ComplexPairTy Op = Visit(E->getSubExpr());
417  llvm::Value *ResI;
418  if (Op.second->getType()->isFloatingPoint())
419    ResI = Builder.CreateFNeg(Op.second, "conj.i");
420  else
421    ResI = Builder.CreateNeg(Op.second, "conj.i");
422
423  return ComplexPairTy(Op.first, ResI);
424}
425
426ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) {
427  llvm::Value *ResR, *ResI;
428
429  if (Op.LHS.first->getType()->isFloatingPoint()) {
430    ResR = Builder.CreateFAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
431    ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i");
432  } else {
433    ResR = Builder.CreateAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
434    ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i");
435  }
436  return ComplexPairTy(ResR, ResI);
437}
438
439ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) {
440  llvm::Value *ResR, *ResI;
441  if (Op.LHS.first->getType()->isFloatingPoint()) {
442    ResR = Builder.CreateFSub(Op.LHS.first,  Op.RHS.first,  "sub.r");
443    ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i");
444  } else {
445    ResR = Builder.CreateSub(Op.LHS.first,  Op.RHS.first,  "sub.r");
446    ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i");
447  }
448  return ComplexPairTy(ResR, ResI);
449}
450
451
452ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) {
453  using llvm::Value;
454  Value *ResR, *ResI;
455
456  if (Op.LHS.first->getType()->isFloatingPoint()) {
457    Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl");
458    Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr");
459    ResR  = Builder.CreateFSub(ResRl, ResRr, "mul.r");
460
461    Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il");
462    Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir");
463    ResI  = Builder.CreateFAdd(ResIl, ResIr, "mul.i");
464  } else {
465    Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl");
466    Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr");
467    ResR  = Builder.CreateSub(ResRl, ResRr, "mul.r");
468
469    Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il");
470    Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir");
471    ResI  = Builder.CreateAdd(ResIl, ResIr, "mul.i");
472  }
473  return ComplexPairTy(ResR, ResI);
474}
475
476ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) {
477  llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
478  llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
479
480
481  llvm::Value *DSTr, *DSTi;
482  if (Op.LHS.first->getType()->isFloatingPoint()) {
483    // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
484    llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr, "tmp"); // a*c
485    llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi, "tmp"); // b*d
486    llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2, "tmp"); // ac+bd
487
488    llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr, "tmp"); // c*c
489    llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi, "tmp"); // d*d
490    llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5, "tmp"); // cc+dd
491
492    llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr, "tmp"); // b*c
493    llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi, "tmp"); // a*d
494    llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8, "tmp"); // bc-ad
495
496    DSTr = Builder.CreateFDiv(Tmp3, Tmp6, "tmp");
497    DSTi = Builder.CreateFDiv(Tmp9, Tmp6, "tmp");
498  } else {
499    // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
500    llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr, "tmp"); // a*c
501    llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi, "tmp"); // b*d
502    llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2, "tmp"); // ac+bd
503
504    llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr, "tmp"); // c*c
505    llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi, "tmp"); // d*d
506    llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5, "tmp"); // cc+dd
507
508    llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr, "tmp"); // b*c
509    llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi, "tmp"); // a*d
510    llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8, "tmp"); // bc-ad
511
512    if (Op.Ty->getAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) {
513      DSTr = Builder.CreateUDiv(Tmp3, Tmp6, "tmp");
514      DSTi = Builder.CreateUDiv(Tmp9, Tmp6, "tmp");
515    } else {
516      DSTr = Builder.CreateSDiv(Tmp3, Tmp6, "tmp");
517      DSTi = Builder.CreateSDiv(Tmp9, Tmp6, "tmp");
518    }
519  }
520
521  return ComplexPairTy(DSTr, DSTi);
522}
523
524ComplexExprEmitter::BinOpInfo
525ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) {
526  TestAndClearIgnoreReal();
527  TestAndClearIgnoreImag();
528  TestAndClearIgnoreRealAssign();
529  TestAndClearIgnoreImagAssign();
530  BinOpInfo Ops;
531  Ops.LHS = Visit(E->getLHS());
532  Ops.RHS = Visit(E->getRHS());
533  Ops.Ty = E->getType();
534  return Ops;
535}
536
537
538// Compound assignments.
539ComplexPairTy ComplexExprEmitter::
540EmitCompoundAssign(const CompoundAssignOperator *E,
541                   ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){
542  TestAndClearIgnoreReal();
543  TestAndClearIgnoreImag();
544  bool ignreal = TestAndClearIgnoreRealAssign();
545  bool ignimag = TestAndClearIgnoreImagAssign();
546  QualType LHSTy = E->getLHS()->getType(), RHSTy = E->getRHS()->getType();
547
548  BinOpInfo OpInfo;
549
550  // Load the RHS and LHS operands.
551  // __block variables need to have the rhs evaluated first, plus this should
552  // improve codegen a little.  It is possible for the RHS to be complex or
553  // scalar.
554  OpInfo.Ty = E->getComputationResultType();
555  OpInfo.RHS = EmitCast(E->getRHS(), OpInfo.Ty);
556
557  LValue LHSLV = CGF.EmitLValue(E->getLHS());
558
559
560  // We know the LHS is a complex lvalue.
561  OpInfo.LHS=EmitLoadOfComplex(LHSLV.getAddress(), LHSLV.isVolatileQualified());
562  OpInfo.LHS=EmitComplexToComplexCast(OpInfo.LHS, LHSTy, OpInfo.Ty);
563
564  // Expand the binary operator.
565  ComplexPairTy Result = (this->*Func)(OpInfo);
566
567  // Truncate the result back to the LHS type.
568  Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy);
569
570  // Store the result value into the LHS lvalue.
571  EmitStoreOfComplex(Result, LHSLV.getAddress(), LHSLV.isVolatileQualified());
572  // And now return the LHS
573  IgnoreReal = ignreal;
574  IgnoreImag = ignimag;
575  IgnoreRealAssign = ignreal;
576  IgnoreImagAssign = ignimag;
577  return EmitLoadOfComplex(LHSLV.getAddress(), LHSLV.isVolatileQualified());
578}
579
580ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
581  TestAndClearIgnoreReal();
582  TestAndClearIgnoreImag();
583  bool ignreal = TestAndClearIgnoreRealAssign();
584  bool ignimag = TestAndClearIgnoreImagAssign();
585  assert(CGF.getContext().getCanonicalType(E->getLHS()->getType()) ==
586         CGF.getContext().getCanonicalType(E->getRHS()->getType()) &&
587         "Invalid assignment");
588  // Emit the RHS.
589  ComplexPairTy Val = Visit(E->getRHS());
590
591  // Compute the address to store into.
592  LValue LHS = CGF.EmitLValue(E->getLHS());
593
594  // Store into it, if simple.
595  if (LHS.isSimple()) {
596    EmitStoreOfComplex(Val, LHS.getAddress(), LHS.isVolatileQualified());
597
598    // And now return the LHS
599    IgnoreReal = ignreal;
600    IgnoreImag = ignimag;
601    IgnoreRealAssign = ignreal;
602    IgnoreImagAssign = ignimag;
603    return EmitLoadOfComplex(LHS.getAddress(), LHS.isVolatileQualified());
604  }
605
606  // Otherwise we must have a property setter (no complex vector/bitfields).
607  if (LHS.isPropertyRef())
608    CGF.EmitObjCPropertySet(LHS.getPropertyRefExpr(), RValue::getComplex(Val));
609  else
610    CGF.EmitObjCPropertySet(LHS.getKVCRefExpr(), RValue::getComplex(Val));
611
612  // There is no reload after a store through a method, but we need to restore
613  // the Ignore* flags.
614  IgnoreReal = ignreal;
615  IgnoreImag = ignimag;
616  IgnoreRealAssign = ignreal;
617  IgnoreImagAssign = ignimag;
618  return Val;
619}
620
621ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) {
622  CGF.EmitStmt(E->getLHS());
623  CGF.EnsureInsertPoint();
624  return Visit(E->getRHS());
625}
626
627ComplexPairTy ComplexExprEmitter::
628VisitConditionalOperator(const ConditionalOperator *E) {
629  if (!E->getLHS()) {
630    CGF.ErrorUnsupported(E, "conditional operator with missing LHS");
631    const llvm::Type *EltTy =
632      CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType());
633    llvm::Value *U = llvm::UndefValue::get(EltTy);
634    return ComplexPairTy(U, U);
635  }
636
637  TestAndClearIgnoreReal();
638  TestAndClearIgnoreImag();
639  TestAndClearIgnoreRealAssign();
640  TestAndClearIgnoreImagAssign();
641  llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
642  llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
643  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
644
645  CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
646
647  CGF.EmitBlock(LHSBlock);
648
649  // Handle the GNU extension for missing LHS.
650  assert(E->getLHS() && "Must have LHS for complex value");
651
652  ComplexPairTy LHS = Visit(E->getLHS());
653  LHSBlock = Builder.GetInsertBlock();
654  CGF.EmitBranch(ContBlock);
655
656  CGF.EmitBlock(RHSBlock);
657
658  ComplexPairTy RHS = Visit(E->getRHS());
659  RHSBlock = Builder.GetInsertBlock();
660  CGF.EmitBranch(ContBlock);
661
662  CGF.EmitBlock(ContBlock);
663
664  // Create a PHI node for the real part.
665  llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), "cond.r");
666  RealPN->reserveOperandSpace(2);
667  RealPN->addIncoming(LHS.first, LHSBlock);
668  RealPN->addIncoming(RHS.first, RHSBlock);
669
670  // Create a PHI node for the imaginary part.
671  llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), "cond.i");
672  ImagPN->reserveOperandSpace(2);
673  ImagPN->addIncoming(LHS.second, LHSBlock);
674  ImagPN->addIncoming(RHS.second, RHSBlock);
675
676  return ComplexPairTy(RealPN, ImagPN);
677}
678
679ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) {
680  return Visit(E->getChosenSubExpr(CGF.getContext()));
681}
682
683ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
684    bool Ignore = TestAndClearIgnoreReal();
685    (void)Ignore;
686    assert (Ignore == false && "init list ignored");
687    Ignore = TestAndClearIgnoreImag();
688    (void)Ignore;
689    assert (Ignore == false && "init list ignored");
690  if (E->getNumInits())
691    return Visit(E->getInit(0));
692
693  // Empty init list intializes to null
694  QualType Ty = E->getType()->getAs<ComplexType>()->getElementType();
695  const llvm::Type* LTy = CGF.ConvertType(Ty);
696  llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
697  return ComplexPairTy(zeroConstant, zeroConstant);
698}
699
700ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
701  llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr());
702  llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType());
703
704  if (!ArgPtr) {
705    CGF.ErrorUnsupported(E, "complex va_arg expression");
706    const llvm::Type *EltTy =
707      CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType());
708    llvm::Value *U = llvm::UndefValue::get(EltTy);
709    return ComplexPairTy(U, U);
710  }
711
712  // FIXME Volatility.
713  return EmitLoadOfComplex(ArgPtr, false);
714}
715
716//===----------------------------------------------------------------------===//
717//                         Entry Point into this File
718//===----------------------------------------------------------------------===//
719
720/// EmitComplexExpr - Emit the computation of the specified expression of
721/// complex type, ignoring the result.
722ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal,
723                                               bool IgnoreImag, bool IgnoreRealAssign, bool IgnoreImagAssign) {
724  assert(E && E->getType()->isAnyComplexType() &&
725         "Invalid complex expression to emit");
726
727  return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag, IgnoreRealAssign,
728                            IgnoreImagAssign)
729    .Visit(const_cast<Expr*>(E));
730}
731
732/// EmitComplexExprIntoAddr - Emit the computation of the specified expression
733/// of complex type, storing into the specified Value*.
734void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E,
735                                              llvm::Value *DestAddr,
736                                              bool DestIsVolatile) {
737  assert(E && E->getType()->isAnyComplexType() &&
738         "Invalid complex expression to emit");
739  ComplexExprEmitter Emitter(*this);
740  ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E));
741  Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile);
742}
743
744/// StoreComplexToAddr - Store a complex number into the specified address.
745void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V,
746                                         llvm::Value *DestAddr,
747                                         bool DestIsVolatile) {
748  ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile);
749}
750
751/// LoadComplexFromAddr - Load a complex number from the specified address.
752ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr,
753                                                   bool SrcIsVolatile) {
754  return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile);
755}
756