CGExprComplex.cpp revision 7976932a1c256d447316ffac58e9821417725e34 
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"
21#include "llvm/Support/Compiler.h"
22using namespace clang;
23using namespace CodeGen;
24
25//===----------------------------------------------------------------------===//
26//                        Complex Expression Emitter
27//===----------------------------------------------------------------------===//
28
29typedef CodeGenFunction::ComplexPairTy ComplexPairTy;
30
31namespace  {
32class VISIBILITY_HIDDEN ComplexExprEmitter
33  : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> {
34  CodeGenFunction &CGF;
35  CGBuilderTy &Builder;
36public:
37  ComplexExprEmitter(CodeGenFunction &cgf) : CGF(cgf), Builder(CGF.Builder) {
38  }
39
40
41  //===--------------------------------------------------------------------===//
42  //                               Utilities
43  //===--------------------------------------------------------------------===//
44
45  /// EmitLoadOfLValue - Given an expression with complex type that represents a
46  /// value l-value, this method emits the address of the l-value, then loads
47  /// and returns the result.
48  ComplexPairTy EmitLoadOfLValue(const Expr *E) {
49    LValue LV = CGF.EmitLValue(E);
50    // FIXME: Volatile
51    return EmitLoadOfComplex(LV.getAddress(), false);
52  }
53
54  /// EmitLoadOfComplex - Given a pointer to a complex value, emit code to load
55  /// the real and imaginary pieces.
56  ComplexPairTy EmitLoadOfComplex(llvm::Value *SrcPtr, bool isVolatile);
57
58  /// EmitStoreOfComplex - Store the specified real/imag parts into the
59  /// specified value pointer.
60  void EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *ResPtr, bool isVol);
61
62  /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
63  ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType,
64                                         QualType DestType);
65
66  //===--------------------------------------------------------------------===//
67  //                            Visitor Methods
68  //===--------------------------------------------------------------------===//
69
70  ComplexPairTy VisitStmt(Stmt *S) {
71    S->dump(CGF.getContext().getSourceManager());
72    assert(0 && "Stmt can't have complex result type!");
73    return ComplexPairTy();
74  }
75  ComplexPairTy VisitExpr(Expr *S);
76  ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
77  ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL);
78
79  // l-values.
80  ComplexPairTy VisitDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); }
81  ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); }
82  ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); }
83
84  // FIXME: CompoundLiteralExpr
85
86  ComplexPairTy EmitCast(Expr *Op, QualType DestTy);
87  ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) {
88    // Unlike for scalars, we don't have to worry about function->ptr demotion
89    // here.
90    return EmitCast(E->getSubExpr(), E->getType());
91  }
92  ComplexPairTy VisitCastExpr(CastExpr *E) {
93    return EmitCast(E->getSubExpr(), E->getType());
94  }
95  ComplexPairTy VisitCallExpr(const CallExpr *E);
96  ComplexPairTy VisitStmtExpr(const StmtExpr *E);
97
98  // Operators.
99  ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E,
100                                   bool isInc, bool isPre);
101  ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) {
102    return VisitPrePostIncDec(E, false, false);
103  }
104  ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) {
105    return VisitPrePostIncDec(E, true, false);
106  }
107  ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) {
108    return VisitPrePostIncDec(E, false, true);
109  }
110  ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) {
111    return VisitPrePostIncDec(E, true, true);
112  }
113  ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
114  ComplexPairTy VisitUnaryPlus     (const UnaryOperator *E) {
115    return Visit(E->getSubExpr());
116  }
117  ComplexPairTy VisitUnaryMinus    (const UnaryOperator *E);
118  ComplexPairTy VisitUnaryNot      (const UnaryOperator *E);
119  // LNot,Real,Imag never return complex.
120  ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) {
121    return Visit(E->getSubExpr());
122  }
123  ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
124    return Visit(DAE->getExpr());
125  }
126  ComplexPairTy VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) {
127    assert(E->getType()->isAnyComplexType() && "Expected complex type!");
128    QualType Elem = E->getType()->getAsComplexType()->getElementType();
129    llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem));
130    return ComplexPairTy(Null, Null);
131  }
132  ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
133    assert(E->getType()->isAnyComplexType() && "Expected complex type!");
134    QualType Elem = E->getType()->getAsComplexType()->getElementType();
135    llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem));
136    return ComplexPairTy(Null, Null);
137  }
138
139  struct BinOpInfo {
140    ComplexPairTy LHS;
141    ComplexPairTy RHS;
142    QualType Ty;  // Computation Type.
143  };
144
145  BinOpInfo EmitBinOps(const BinaryOperator *E);
146  ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E,
147                                   ComplexPairTy (ComplexExprEmitter::*Func)
148                                   (const BinOpInfo &));
149
150  ComplexPairTy EmitBinAdd(const BinOpInfo &Op);
151  ComplexPairTy EmitBinSub(const BinOpInfo &Op);
152  ComplexPairTy EmitBinMul(const BinOpInfo &Op);
153  ComplexPairTy EmitBinDiv(const BinOpInfo &Op);
154
155  ComplexPairTy VisitBinMul(const BinaryOperator *E) {
156    return EmitBinMul(EmitBinOps(E));
157  }
158  ComplexPairTy VisitBinAdd(const BinaryOperator *E) {
159    return EmitBinAdd(EmitBinOps(E));
160  }
161  ComplexPairTy VisitBinSub(const BinaryOperator *E) {
162    return EmitBinSub(EmitBinOps(E));
163  }
164  ComplexPairTy VisitBinDiv(const BinaryOperator *E) {
165    return EmitBinDiv(EmitBinOps(E));
166  }
167
168  // Compound assignments.
169  ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) {
170    return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd);
171  }
172  ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) {
173    return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub);
174  }
175  ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) {
176    return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul);
177  }
178  ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) {
179    return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv);
180  }
181
182  // GCC rejects rem/and/or/xor for integer complex.
183  // Logical and/or always return int, never complex.
184
185  // No comparisons produce a complex result.
186  ComplexPairTy VisitBinAssign     (const BinaryOperator *E);
187  ComplexPairTy VisitBinComma      (const BinaryOperator *E);
188
189
190  ComplexPairTy VisitConditionalOperator(const ConditionalOperator *CO);
191  ComplexPairTy VisitChooseExpr(ChooseExpr *CE);
192
193  ComplexPairTy VisitInitListExpr(InitListExpr *E);
194
195  ComplexPairTy VisitVAArgExpr(VAArgExpr *E);
196};
197}  // end anonymous namespace.
198
199//===----------------------------------------------------------------------===//
200//                                Utilities
201//===----------------------------------------------------------------------===//
202
203/// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to
204/// load the real and imaginary pieces, returning them as Real/Imag.
205ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr,
206                                                    bool isVolatile) {
207  llvm::SmallString<64> Name(SrcPtr->getNameStart(),
208                             SrcPtr->getNameStart()+SrcPtr->getNameLen());
209
210  Name += ".realp";
211  llvm::Value *RealPtr = Builder.CreateStructGEP(SrcPtr, 0, Name.c_str());
212
213  Name.pop_back();  // .realp -> .real
214  llvm::Value *Real = Builder.CreateLoad(RealPtr, isVolatile, Name.c_str());
215
216  Name.resize(Name.size()-4); // .real -> .imagp
217  Name += "imagp";
218
219  llvm::Value *ImagPtr = Builder.CreateStructGEP(SrcPtr, 1, Name.c_str());
220
221  Name.pop_back();  // .imagp -> .imag
222  llvm::Value *Imag = Builder.CreateLoad(ImagPtr, isVolatile, Name.c_str());
223  return ComplexPairTy(Real, Imag);
224}
225
226/// EmitStoreOfComplex - Store the specified real/imag parts into the
227/// specified value pointer.
228void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *Ptr,
229                                            bool isVolatile) {
230  llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real");
231  llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag");
232
233  Builder.CreateStore(Val.first, RealPtr, isVolatile);
234  Builder.CreateStore(Val.second, ImagPtr, isVolatile);
235}
236
237
238
239//===----------------------------------------------------------------------===//
240//                            Visitor Methods
241//===----------------------------------------------------------------------===//
242
243ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
244  CGF.ErrorUnsupported(E, "complex expression");
245  const llvm::Type *EltTy =
246    CGF.ConvertType(E->getType()->getAsComplexType()->getElementType());
247  llvm::Value *U = llvm::UndefValue::get(EltTy);
248  return ComplexPairTy(U, U);
249}
250
251ComplexPairTy ComplexExprEmitter::
252VisitImaginaryLiteral(const ImaginaryLiteral *IL) {
253  llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr());
254  return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag);
255}
256
257
258ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
259  return CGF.EmitCallExpr(E).getComplexVal();
260}
261
262ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) {
263  return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal();
264}
265
266/// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
267ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val,
268                                                           QualType SrcType,
269                                                           QualType DestType) {
270  // Get the src/dest element type.
271  SrcType = SrcType->getAsComplexType()->getElementType();
272  DestType = DestType->getAsComplexType()->getElementType();
273
274  // C99 6.3.1.6: When a value of complex type is converted to another
275  // complex type, both the real and imaginary parts follow the conversion
276  // rules for the corresponding real types.
277  Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType);
278  Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType);
279  return Val;
280}
281
282ComplexPairTy ComplexExprEmitter::EmitCast(Expr *Op, QualType DestTy) {
283  // Two cases here: cast from (complex to complex) and (scalar to complex).
284  if (Op->getType()->isAnyComplexType())
285    return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy);
286
287  // C99 6.3.1.7: When a value of real type is converted to a complex type, the
288  // real part of the complex  result value is determined by the rules of
289  // conversion to the corresponding real type and the imaginary part of the
290  // complex result value is a positive zero or an unsigned zero.
291  llvm::Value *Elt = CGF.EmitScalarExpr(Op);
292
293  // Convert the input element to the element type of the complex.
294  DestTy = DestTy->getAsComplexType()->getElementType();
295  Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy);
296
297  // Return (realval, 0).
298  return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType()));
299}
300
301ComplexPairTy ComplexExprEmitter::VisitPrePostIncDec(const UnaryOperator *E,
302                                                     bool isInc, bool isPre) {
303  LValue LV = CGF.EmitLValue(E->getSubExpr());
304  // FIXME: Handle volatile!
305  ComplexPairTy InVal = EmitLoadOfComplex(LV.getAddress(), false);
306
307  uint64_t AmountVal = isInc ? 1 : -1;
308
309  llvm::Value *NextVal;
310  if (isa<llvm::IntegerType>(InVal.first->getType()))
311    NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal);
312  else if (InVal.first->getType() == llvm::Type::FloatTy)
313    // FIXME: Handle long double.
314    NextVal =
315      llvm::ConstantFP::get(llvm::APFloat(static_cast<float>(AmountVal)));
316  else {
317    // FIXME: Handle long double.
318    assert(InVal.first->getType() == llvm::Type::DoubleTy);
319    NextVal =
320      llvm::ConstantFP::get(llvm::APFloat(static_cast<double>(AmountVal)));
321  }
322
323  // Add the inc/dec to the real part.
324  NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
325
326  ComplexPairTy IncVal(NextVal, InVal.second);
327
328  // Store the updated result through the lvalue.
329  EmitStoreOfComplex(IncVal, LV.getAddress(), false);  /* FIXME: Volatile */
330
331  // If this is a postinc, return the value read from memory, otherwise use the
332  // updated value.
333  return isPre ? IncVal : InVal;
334}
335
336ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
337  ComplexPairTy Op = Visit(E->getSubExpr());
338  llvm::Value *ResR = Builder.CreateNeg(Op.first,  "neg.r");
339  llvm::Value *ResI = Builder.CreateNeg(Op.second, "neg.i");
340  return ComplexPairTy(ResR, ResI);
341}
342
343ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
344  // ~(a+ib) = a + i*-b
345  ComplexPairTy Op = Visit(E->getSubExpr());
346  llvm::Value *ResI = Builder.CreateNeg(Op.second, "conj.i");
347  return ComplexPairTy(Op.first, ResI);
348}
349
350ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) {
351  llvm::Value *ResR = Builder.CreateAdd(Op.LHS.first,  Op.RHS.first,  "add.r");
352  llvm::Value *ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i");
353  return ComplexPairTy(ResR, ResI);
354}
355
356ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) {
357  llvm::Value *ResR = Builder.CreateSub(Op.LHS.first,  Op.RHS.first,  "sub.r");
358  llvm::Value *ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i");
359  return ComplexPairTy(ResR, ResI);
360}
361
362
363ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) {
364  llvm::Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl");
365  llvm::Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr");
366  llvm::Value *ResR  = Builder.CreateSub(ResRl, ResRr, "mul.r");
367
368  llvm::Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il");
369  llvm::Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir");
370  llvm::Value *ResI  = Builder.CreateAdd(ResIl, ResIr, "mul.i");
371  return ComplexPairTy(ResR, ResI);
372}
373
374ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) {
375  llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
376  llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
377
378  // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
379  llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr, "tmp"); // a*c
380  llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi, "tmp"); // b*d
381  llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2, "tmp"); // ac+bd
382
383  llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr, "tmp"); // c*c
384  llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi, "tmp"); // d*d
385  llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5, "tmp"); // cc+dd
386
387  llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr, "tmp"); // b*c
388  llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi, "tmp"); // a*d
389  llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8, "tmp"); // bc-ad
390
391  llvm::Value *DSTr, *DSTi;
392  if (Tmp3->getType()->isFloatingPoint()) {
393    DSTr = Builder.CreateFDiv(Tmp3, Tmp6, "tmp");
394    DSTi = Builder.CreateFDiv(Tmp9, Tmp6, "tmp");
395  } else {
396    if (Op.Ty->getAsComplexType()->getElementType()->isUnsignedIntegerType()) {
397      DSTr = Builder.CreateUDiv(Tmp3, Tmp6, "tmp");
398      DSTi = Builder.CreateUDiv(Tmp9, Tmp6, "tmp");
399    } else {
400      DSTr = Builder.CreateSDiv(Tmp3, Tmp6, "tmp");
401      DSTi = Builder.CreateSDiv(Tmp9, Tmp6, "tmp");
402    }
403  }
404
405  return ComplexPairTy(DSTr, DSTi);
406}
407
408ComplexExprEmitter::BinOpInfo
409ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) {
410  BinOpInfo Ops;
411  Ops.LHS = Visit(E->getLHS());
412  Ops.RHS = Visit(E->getRHS());
413  Ops.Ty = E->getType();
414  return Ops;
415}
416
417
418// Compound assignments.
419ComplexPairTy ComplexExprEmitter::
420EmitCompoundAssign(const CompoundAssignOperator *E,
421                   ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){
422  QualType LHSTy = E->getLHS()->getType(), RHSTy = E->getRHS()->getType();
423
424  // Load the LHS and RHS operands.
425  LValue LHSLV = CGF.EmitLValue(E->getLHS());
426
427  BinOpInfo OpInfo;
428  OpInfo.Ty = E->getComputationType();
429
430  // We know the LHS is a complex lvalue.
431  OpInfo.LHS = EmitLoadOfComplex(LHSLV.getAddress(), false);// FIXME: Volatile.
432  OpInfo.LHS = EmitComplexToComplexCast(OpInfo.LHS, LHSTy, OpInfo.Ty);
433
434  // It is possible for the RHS to be complex or scalar.
435  OpInfo.RHS = EmitCast(E->getRHS(), OpInfo.Ty);
436
437  // Expand the binary operator.
438  ComplexPairTy Result = (this->*Func)(OpInfo);
439
440  // Truncate the result back to the LHS type.
441  Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy);
442
443  // Store the result value into the LHS lvalue.
444  EmitStoreOfComplex(Result, LHSLV.getAddress(), false); // FIXME: VOLATILE
445  return Result;
446}
447
448ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
449  assert(CGF.getContext().getCanonicalType(E->getLHS()->getType()) ==
450         CGF.getContext().getCanonicalType(E->getRHS()->getType()) &&
451         "Invalid assignment");
452  // Emit the RHS.
453  ComplexPairTy Val = Visit(E->getRHS());
454
455  // Compute the address to store into.
456  LValue LHS = CGF.EmitLValue(E->getLHS());
457
458  // Store into it.
459  // FIXME: Volatility!
460  EmitStoreOfComplex(Val, LHS.getAddress(), false);
461  return Val;
462}
463
464ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) {
465  CGF.EmitStmt(E->getLHS());
466  CGF.EnsureInsertPoint();
467  return Visit(E->getRHS());
468}
469
470ComplexPairTy ComplexExprEmitter::
471VisitConditionalOperator(const ConditionalOperator *E) {
472  llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
473  llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
474  llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
475
476  llvm::Value *Cond = CGF.EvaluateExprAsBool(E->getCond());
477  Builder.CreateCondBr(Cond, LHSBlock, RHSBlock);
478
479  CGF.EmitBlock(LHSBlock);
480
481  // Handle the GNU extension for missing LHS.
482  assert(E->getLHS() && "Must have LHS for complex value");
483
484  ComplexPairTy LHS = Visit(E->getLHS());
485  LHSBlock = Builder.GetInsertBlock();
486  CGF.EmitBranch(ContBlock);
487
488  CGF.EmitBlock(RHSBlock);
489
490  ComplexPairTy RHS = Visit(E->getRHS());
491  RHSBlock = Builder.GetInsertBlock();
492  CGF.EmitBranch(ContBlock);
493
494  CGF.EmitBlock(ContBlock);
495
496  // Create a PHI node for the real part.
497  llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), "cond.r");
498  RealPN->reserveOperandSpace(2);
499  RealPN->addIncoming(LHS.first, LHSBlock);
500  RealPN->addIncoming(RHS.first, RHSBlock);
501
502  // Create a PHI node for the imaginary part.
503  llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), "cond.i");
504  ImagPN->reserveOperandSpace(2);
505  ImagPN->addIncoming(LHS.second, LHSBlock);
506  ImagPN->addIncoming(RHS.second, RHSBlock);
507
508  return ComplexPairTy(RealPN, ImagPN);
509}
510
511ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) {
512  return Visit(E->getChosenSubExpr(CGF.getContext()));
513}
514
515ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
516  if (E->getNumInits())
517    return Visit(E->getInit(0));
518
519  // Empty init list intializes to null
520  QualType Ty = E->getType()->getAsComplexType()->getElementType();
521  const llvm::Type* LTy = CGF.ConvertType(Ty);
522  llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
523  return ComplexPairTy(zeroConstant, zeroConstant);
524}
525
526ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
527  llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr());
528  llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType());
529
530  if (!ArgPtr) {
531    CGF.ErrorUnsupported(E, "complex va_arg expression");
532    const llvm::Type *EltTy =
533      CGF.ConvertType(E->getType()->getAsComplexType()->getElementType());
534    llvm::Value *U = llvm::UndefValue::get(EltTy);
535    return ComplexPairTy(U, U);
536  }
537
538  // FIXME Volatility.
539  return EmitLoadOfComplex(ArgPtr, false);
540}
541
542//===----------------------------------------------------------------------===//
543//                         Entry Point into this File
544//===----------------------------------------------------------------------===//
545
546/// EmitComplexExpr - Emit the computation of the specified expression of
547/// complex type, ignoring the result.
548ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E) {
549  assert(E && E->getType()->isAnyComplexType() &&
550         "Invalid complex expression to emit");
551
552  return ComplexExprEmitter(*this).Visit(const_cast<Expr*>(E));
553}
554
555/// EmitComplexExprIntoAddr - Emit the computation of the specified expression
556/// of complex type, storing into the specified Value*.
557void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E,
558                                              llvm::Value *DestAddr,
559                                              bool DestIsVolatile) {
560  assert(E && E->getType()->isAnyComplexType() &&
561         "Invalid complex expression to emit");
562  ComplexExprEmitter Emitter(*this);
563  ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E));
564  Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile);
565}
566
567/// StoreComplexToAddr - Store a complex number into the specified address.
568void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V,
569                                         llvm::Value *DestAddr,
570                                         bool DestIsVolatile) {
571  ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile);
572}
573
574/// LoadComplexFromAddr - Load a complex number from the specified address.
575ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr,
576                                                   bool SrcIsVolatile) {
577  return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile);
578}
579