1 //===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This contains code to emit Expr nodes with complex types as LLVM code.
12 //===----------------------------------------------------------------------===//
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 using namespace clang;
22 using namespace CodeGen;
24 //===----------------------------------------------------------------------===//
25 // Complex Expression Emitter
26 //===----------------------------------------------------------------------===//
28 typedef CodeGenFunction::ComplexPairTy ComplexPairTy;
31 class ComplexExprEmitter
32 : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> {
35 // True is we should ignore the value of a
39 ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false)
40 : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) {
44 //===--------------------------------------------------------------------===//
46 //===--------------------------------------------------------------------===//
48 bool TestAndClearIgnoreReal() {
53 bool TestAndClearIgnoreImag() {
59 /// EmitLoadOfLValue - Given an expression with complex type that represents a
60 /// value l-value, this method emits the address of the l-value, then loads
61 /// and returns the result.
62 ComplexPairTy EmitLoadOfLValue(const Expr *E) {
63 return EmitLoadOfLValue(CGF.EmitLValue(E));
66 ComplexPairTy EmitLoadOfLValue(LValue LV) {
68 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified());
70 assert(LV.isPropertyRef() && "Unknown LValue type!");
71 return CGF.EmitLoadOfPropertyRefLValue(LV).getComplexVal();
74 /// EmitLoadOfComplex - Given a pointer to a complex value, emit code to load
75 /// the real and imaginary pieces.
76 ComplexPairTy EmitLoadOfComplex(llvm::Value *SrcPtr, bool isVolatile);
78 /// EmitStoreThroughLValue - Given an l-value of complex type, store
79 /// a complex number into it.
80 void EmitStoreThroughLValue(ComplexPairTy Val, LValue LV) {
82 return EmitStoreOfComplex(Val, LV.getAddress(), LV.isVolatileQualified());
84 assert(LV.isPropertyRef() && "Unknown LValue type!");
85 CGF.EmitStoreThroughPropertyRefLValue(RValue::getComplex(Val), LV);
88 /// EmitStoreOfComplex - Store the specified real/imag parts into the
89 /// specified value pointer.
90 void EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *ResPtr, bool isVol);
92 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
93 ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType,
96 //===--------------------------------------------------------------------===//
98 //===--------------------------------------------------------------------===//
100 ComplexPairTy Visit(Expr *E) {
101 return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E);
104 ComplexPairTy VisitStmt(Stmt *S) {
105 S->dump(CGF.getContext().getSourceManager());
106 llvm_unreachable("Stmt can't have complex result type!");
108 ComplexPairTy VisitExpr(Expr *S);
109 ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
110 ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
111 return Visit(GE->getResultExpr());
113 ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL);
115 VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
116 return Visit(PE->getReplacement());
120 ComplexPairTy VisitDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); }
121 ComplexPairTy VisitBlockDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); }
122 ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
123 return EmitLoadOfLValue(E);
125 ComplexPairTy VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
126 assert(E->getObjectKind() == OK_Ordinary);
127 return EmitLoadOfLValue(E);
129 ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) {
130 return CGF.EmitObjCMessageExpr(E).getComplexVal();
132 ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); }
133 ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); }
134 ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) {
136 return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E));
137 return CGF.getOpaqueRValueMapping(E).getComplexVal();
140 // FIXME: CompoundLiteralExpr
142 ComplexPairTy EmitCast(CastExpr::CastKind CK, Expr *Op, QualType DestTy);
143 ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) {
144 // Unlike for scalars, we don't have to worry about function->ptr demotion
146 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
148 ComplexPairTy VisitCastExpr(CastExpr *E) {
149 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
151 ComplexPairTy VisitCallExpr(const CallExpr *E);
152 ComplexPairTy VisitStmtExpr(const StmtExpr *E);
155 ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E,
156 bool isInc, bool isPre) {
157 LValue LV = CGF.EmitLValue(E->getSubExpr());
158 return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre);
160 ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) {
161 return VisitPrePostIncDec(E, false, false);
163 ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) {
164 return VisitPrePostIncDec(E, true, false);
166 ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) {
167 return VisitPrePostIncDec(E, false, true);
169 ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) {
170 return VisitPrePostIncDec(E, true, true);
172 ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
173 ComplexPairTy VisitUnaryPlus (const UnaryOperator *E) {
174 TestAndClearIgnoreReal();
175 TestAndClearIgnoreImag();
176 return Visit(E->getSubExpr());
178 ComplexPairTy VisitUnaryMinus (const UnaryOperator *E);
179 ComplexPairTy VisitUnaryNot (const UnaryOperator *E);
180 // LNot,Real,Imag never return complex.
181 ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) {
182 return Visit(E->getSubExpr());
184 ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
185 return Visit(DAE->getExpr());
187 ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) {
188 return CGF.EmitExprWithCleanups(E).getComplexVal();
190 ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
191 assert(E->getType()->isAnyComplexType() && "Expected complex type!");
192 QualType Elem = E->getType()->getAs<ComplexType>()->getElementType();
193 llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem));
194 return ComplexPairTy(Null, Null);
196 ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
197 assert(E->getType()->isAnyComplexType() && "Expected complex type!");
198 QualType Elem = E->getType()->getAs<ComplexType>()->getElementType();
199 llvm::Constant *Null =
200 llvm::Constant::getNullValue(CGF.ConvertType(Elem));
201 return ComplexPairTy(Null, Null);
207 QualType Ty; // Computation Type.
210 BinOpInfo EmitBinOps(const BinaryOperator *E);
211 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
212 ComplexPairTy (ComplexExprEmitter::*Func)
215 ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E,
216 ComplexPairTy (ComplexExprEmitter::*Func)
217 (const BinOpInfo &));
219 ComplexPairTy EmitBinAdd(const BinOpInfo &Op);
220 ComplexPairTy EmitBinSub(const BinOpInfo &Op);
221 ComplexPairTy EmitBinMul(const BinOpInfo &Op);
222 ComplexPairTy EmitBinDiv(const BinOpInfo &Op);
224 ComplexPairTy VisitBinAdd(const BinaryOperator *E) {
225 return EmitBinAdd(EmitBinOps(E));
227 ComplexPairTy VisitBinSub(const BinaryOperator *E) {
228 return EmitBinSub(EmitBinOps(E));
230 ComplexPairTy VisitBinMul(const BinaryOperator *E) {
231 return EmitBinMul(EmitBinOps(E));
233 ComplexPairTy VisitBinDiv(const BinaryOperator *E) {
234 return EmitBinDiv(EmitBinOps(E));
237 // Compound assignments.
238 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) {
239 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd);
241 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) {
242 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub);
244 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) {
245 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul);
247 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) {
248 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv);
251 // GCC rejects rem/and/or/xor for integer complex.
252 // Logical and/or always return int, never complex.
254 // No comparisons produce a complex result.
256 LValue EmitBinAssignLValue(const BinaryOperator *E,
258 ComplexPairTy VisitBinAssign (const BinaryOperator *E);
259 ComplexPairTy VisitBinComma (const BinaryOperator *E);
263 VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
264 ComplexPairTy VisitChooseExpr(ChooseExpr *CE);
266 ComplexPairTy VisitInitListExpr(InitListExpr *E);
268 ComplexPairTy VisitVAArgExpr(VAArgExpr *E);
270 ComplexPairTy VisitAtomicExpr(AtomicExpr *E) {
271 return CGF.EmitAtomicExpr(E).getComplexVal();
274 } // end anonymous namespace.
276 //===----------------------------------------------------------------------===//
278 //===----------------------------------------------------------------------===//
280 /// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to
281 /// load the real and imaginary pieces, returning them as Real/Imag.
282 ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr,
284 llvm::Value *Real=0, *Imag=0;
286 if (!IgnoreReal || isVolatile) {
287 llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0,
288 SrcPtr->getName() + ".realp");
289 Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr->getName() + ".real");
292 if (!IgnoreImag || isVolatile) {
293 llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1,
294 SrcPtr->getName() + ".imagp");
295 Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr->getName() + ".imag");
297 return ComplexPairTy(Real, Imag);
300 /// EmitStoreOfComplex - Store the specified real/imag parts into the
301 /// specified value pointer.
302 void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *Ptr,
304 llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real");
305 llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag");
307 Builder.CreateStore(Val.first, RealPtr, isVolatile);
308 Builder.CreateStore(Val.second, ImagPtr, isVolatile);
313 //===----------------------------------------------------------------------===//
315 //===----------------------------------------------------------------------===//
317 ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
318 CGF.ErrorUnsupported(E, "complex expression");
320 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType());
321 llvm::Value *U = llvm::UndefValue::get(EltTy);
322 return ComplexPairTy(U, U);
325 ComplexPairTy ComplexExprEmitter::
326 VisitImaginaryLiteral(const ImaginaryLiteral *IL) {
327 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr());
328 return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag);
332 ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
333 if (E->getCallReturnType()->isReferenceType())
334 return EmitLoadOfLValue(E);
336 return CGF.EmitCallExpr(E).getComplexVal();
339 ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) {
340 CodeGenFunction::StmtExprEvaluation eval(CGF);
341 return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal();
344 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
345 ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val,
348 // Get the src/dest element type.
349 SrcType = SrcType->getAs<ComplexType>()->getElementType();
350 DestType = DestType->getAs<ComplexType>()->getElementType();
352 // C99 6.3.1.6: When a value of complex type is converted to another
353 // complex type, both the real and imaginary parts follow the conversion
354 // rules for the corresponding real types.
355 Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType);
356 Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType);
360 ComplexPairTy ComplexExprEmitter::EmitCast(CastExpr::CastKind CK, Expr *Op,
363 case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!");
365 case CK_GetObjCProperty: {
366 LValue LV = CGF.EmitLValue(Op);
367 assert(LV.isPropertyRef() && "Unknown LValue type!");
368 return CGF.EmitLoadOfPropertyRefLValue(LV).getComplexVal();
372 case CK_LValueToRValue:
373 case CK_UserDefinedConversion:
376 case CK_LValueBitCast: {
377 llvm::Value *V = CGF.EmitLValue(Op).getAddress();
378 V = Builder.CreateBitCast(V,
379 CGF.ConvertType(CGF.getContext().getPointerType(DestTy)));
380 // FIXME: Are the qualifiers correct here?
381 return EmitLoadOfComplex(V, DestTy.isVolatileQualified());
385 case CK_BaseToDerived:
386 case CK_DerivedToBase:
387 case CK_UncheckedDerivedToBase:
390 case CK_ArrayToPointerDecay:
391 case CK_FunctionToPointerDecay:
392 case CK_NullToPointer:
393 case CK_NullToMemberPointer:
394 case CK_BaseToDerivedMemberPointer:
395 case CK_DerivedToBaseMemberPointer:
396 case CK_MemberPointerToBoolean:
397 case CK_ConstructorConversion:
398 case CK_IntegralToPointer:
399 case CK_PointerToIntegral:
400 case CK_PointerToBoolean:
403 case CK_IntegralCast:
404 case CK_IntegralToBoolean:
405 case CK_IntegralToFloating:
406 case CK_FloatingToIntegral:
407 case CK_FloatingToBoolean:
408 case CK_FloatingCast:
409 case CK_CPointerToObjCPointerCast:
410 case CK_BlockPointerToObjCPointerCast:
411 case CK_AnyPointerToBlockPointerCast:
412 case CK_ObjCObjectLValueCast:
413 case CK_FloatingComplexToReal:
414 case CK_FloatingComplexToBoolean:
415 case CK_IntegralComplexToReal:
416 case CK_IntegralComplexToBoolean:
417 case CK_ARCProduceObject:
418 case CK_ARCConsumeObject:
419 case CK_ARCReclaimReturnedObject:
420 case CK_ARCExtendBlockObject:
421 llvm_unreachable("invalid cast kind for complex value");
423 case CK_FloatingRealToComplex:
424 case CK_IntegralRealToComplex: {
425 llvm::Value *Elt = CGF.EmitScalarExpr(Op);
427 // Convert the input element to the element type of the complex.
428 DestTy = DestTy->getAs<ComplexType>()->getElementType();
429 Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy);
431 // Return (realval, 0).
432 return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType()));
435 case CK_FloatingComplexCast:
436 case CK_FloatingComplexToIntegralComplex:
437 case CK_IntegralComplexCast:
438 case CK_IntegralComplexToFloatingComplex:
439 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy);
442 llvm_unreachable("unknown cast resulting in complex value");
445 ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
446 TestAndClearIgnoreReal();
447 TestAndClearIgnoreImag();
448 ComplexPairTy Op = Visit(E->getSubExpr());
450 llvm::Value *ResR, *ResI;
451 if (Op.first->getType()->isFloatingPointTy()) {
452 ResR = Builder.CreateFNeg(Op.first, "neg.r");
453 ResI = Builder.CreateFNeg(Op.second, "neg.i");
455 ResR = Builder.CreateNeg(Op.first, "neg.r");
456 ResI = Builder.CreateNeg(Op.second, "neg.i");
458 return ComplexPairTy(ResR, ResI);
461 ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
462 TestAndClearIgnoreReal();
463 TestAndClearIgnoreImag();
464 // ~(a+ib) = a + i*-b
465 ComplexPairTy Op = Visit(E->getSubExpr());
467 if (Op.second->getType()->isFloatingPointTy())
468 ResI = Builder.CreateFNeg(Op.second, "conj.i");
470 ResI = Builder.CreateNeg(Op.second, "conj.i");
472 return ComplexPairTy(Op.first, ResI);
475 ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) {
476 llvm::Value *ResR, *ResI;
478 if (Op.LHS.first->getType()->isFloatingPointTy()) {
479 ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r");
480 ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i");
482 ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r");
483 ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i");
485 return ComplexPairTy(ResR, ResI);
488 ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) {
489 llvm::Value *ResR, *ResI;
490 if (Op.LHS.first->getType()->isFloatingPointTy()) {
491 ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r");
492 ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i");
494 ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r");
495 ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i");
497 return ComplexPairTy(ResR, ResI);
501 ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) {
505 if (Op.LHS.first->getType()->isFloatingPointTy()) {
506 Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl");
507 Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr");
508 ResR = Builder.CreateFSub(ResRl, ResRr, "mul.r");
510 Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il");
511 Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir");
512 ResI = Builder.CreateFAdd(ResIl, ResIr, "mul.i");
514 Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl");
515 Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr");
516 ResR = Builder.CreateSub(ResRl, ResRr, "mul.r");
518 Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il");
519 Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir");
520 ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i");
522 return ComplexPairTy(ResR, ResI);
525 ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) {
526 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
527 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
530 llvm::Value *DSTr, *DSTi;
531 if (Op.LHS.first->getType()->isFloatingPointTy()) {
532 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
533 llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr); // a*c
534 llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi); // b*d
535 llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2); // ac+bd
537 llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr); // c*c
538 llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi); // d*d
539 llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5); // cc+dd
541 llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr); // b*c
542 llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi); // a*d
543 llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8); // bc-ad
545 DSTr = Builder.CreateFDiv(Tmp3, Tmp6);
546 DSTi = Builder.CreateFDiv(Tmp9, Tmp6);
548 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
549 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c
550 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d
551 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd
553 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c
554 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d
555 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd
557 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c
558 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d
559 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad
561 if (Op.Ty->getAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) {
562 DSTr = Builder.CreateUDiv(Tmp3, Tmp6);
563 DSTi = Builder.CreateUDiv(Tmp9, Tmp6);
565 DSTr = Builder.CreateSDiv(Tmp3, Tmp6);
566 DSTi = Builder.CreateSDiv(Tmp9, Tmp6);
570 return ComplexPairTy(DSTr, DSTi);
573 ComplexExprEmitter::BinOpInfo
574 ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) {
575 TestAndClearIgnoreReal();
576 TestAndClearIgnoreImag();
578 Ops.LHS = Visit(E->getLHS());
579 Ops.RHS = Visit(E->getRHS());
580 Ops.Ty = E->getType();
585 LValue ComplexExprEmitter::
586 EmitCompoundAssignLValue(const CompoundAssignOperator *E,
587 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&),
588 ComplexPairTy &Val) {
589 TestAndClearIgnoreReal();
590 TestAndClearIgnoreImag();
591 QualType LHSTy = E->getLHS()->getType();
595 // Load the RHS and LHS operands.
596 // __block variables need to have the rhs evaluated first, plus this should
597 // improve codegen a little.
598 OpInfo.Ty = E->getComputationResultType();
600 // The RHS should have been converted to the computation type.
601 assert(OpInfo.Ty->isAnyComplexType());
602 assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty,
603 E->getRHS()->getType()));
604 OpInfo.RHS = Visit(E->getRHS());
606 LValue LHS = CGF.EmitLValue(E->getLHS());
608 // Load from the l-value.
609 ComplexPairTy LHSComplexPair = EmitLoadOfLValue(LHS);
611 OpInfo.LHS = EmitComplexToComplexCast(LHSComplexPair, LHSTy, OpInfo.Ty);
613 // Expand the binary operator.
614 ComplexPairTy Result = (this->*Func)(OpInfo);
616 // Truncate the result back to the LHS type.
617 Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy);
620 // Store the result value into the LHS lvalue.
621 EmitStoreThroughLValue(Result, LHS);
626 // Compound assignments.
627 ComplexPairTy ComplexExprEmitter::
628 EmitCompoundAssign(const CompoundAssignOperator *E,
629 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){
631 LValue LV = EmitCompoundAssignLValue(E, Func, Val);
633 // The result of an assignment in C is the assigned r-value.
634 if (!CGF.getContext().getLangOptions().CPlusPlus)
637 // Objective-C property assignment never reloads the value following a store.
638 if (LV.isPropertyRef())
641 // If the lvalue is non-volatile, return the computed value of the assignment.
642 if (!LV.isVolatileQualified())
645 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified());
648 LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E,
649 ComplexPairTy &Val) {
650 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
651 E->getRHS()->getType()) &&
652 "Invalid assignment");
653 TestAndClearIgnoreReal();
654 TestAndClearIgnoreImag();
656 // Emit the RHS. __block variables need the RHS evaluated first.
657 Val = Visit(E->getRHS());
659 // Compute the address to store into.
660 LValue LHS = CGF.EmitLValue(E->getLHS());
662 // Store the result value into the LHS lvalue.
663 EmitStoreThroughLValue(Val, LHS);
668 ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
670 LValue LV = EmitBinAssignLValue(E, Val);
672 // The result of an assignment in C is the assigned r-value.
673 if (!CGF.getContext().getLangOptions().CPlusPlus)
676 // Objective-C property assignment never reloads the value following a store.
677 if (LV.isPropertyRef())
680 // If the lvalue is non-volatile, return the computed value of the assignment.
681 if (!LV.isVolatileQualified())
684 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified());
687 ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) {
688 CGF.EmitIgnoredExpr(E->getLHS());
689 return Visit(E->getRHS());
692 ComplexPairTy ComplexExprEmitter::
693 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
694 TestAndClearIgnoreReal();
695 TestAndClearIgnoreImag();
696 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
697 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
698 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
700 // Bind the common expression if necessary.
701 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
703 CodeGenFunction::ConditionalEvaluation eval(CGF);
704 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
707 CGF.EmitBlock(LHSBlock);
708 ComplexPairTy LHS = Visit(E->getTrueExpr());
709 LHSBlock = Builder.GetInsertBlock();
710 CGF.EmitBranch(ContBlock);
714 CGF.EmitBlock(RHSBlock);
715 ComplexPairTy RHS = Visit(E->getFalseExpr());
716 RHSBlock = Builder.GetInsertBlock();
717 CGF.EmitBlock(ContBlock);
720 // Create a PHI node for the real part.
721 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r");
722 RealPN->addIncoming(LHS.first, LHSBlock);
723 RealPN->addIncoming(RHS.first, RHSBlock);
725 // Create a PHI node for the imaginary part.
726 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i");
727 ImagPN->addIncoming(LHS.second, LHSBlock);
728 ImagPN->addIncoming(RHS.second, RHSBlock);
730 return ComplexPairTy(RealPN, ImagPN);
733 ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) {
734 return Visit(E->getChosenSubExpr(CGF.getContext()));
737 ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
738 bool Ignore = TestAndClearIgnoreReal();
740 assert (Ignore == false && "init list ignored");
741 Ignore = TestAndClearIgnoreImag();
743 assert (Ignore == false && "init list ignored");
745 if (E->getNumInits() == 2) {
746 llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0));
747 llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1));
748 return ComplexPairTy(Real, Imag);
749 } else if (E->getNumInits() == 1) {
750 return Visit(E->getInit(0));
753 // Empty init list intializes to null
754 assert(E->getNumInits() == 0 && "Unexpected number of inits");
755 QualType Ty = E->getType()->getAs<ComplexType>()->getElementType();
756 llvm::Type* LTy = CGF.ConvertType(Ty);
757 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
758 return ComplexPairTy(zeroConstant, zeroConstant);
761 ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
762 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr());
763 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType());
766 CGF.ErrorUnsupported(E, "complex va_arg expression");
768 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType());
769 llvm::Value *U = llvm::UndefValue::get(EltTy);
770 return ComplexPairTy(U, U);
774 return EmitLoadOfComplex(ArgPtr, false);
777 //===----------------------------------------------------------------------===//
778 // Entry Point into this File
779 //===----------------------------------------------------------------------===//
781 /// EmitComplexExpr - Emit the computation of the specified expression of
782 /// complex type, ignoring the result.
783 ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal,
785 assert(E && E->getType()->isAnyComplexType() &&
786 "Invalid complex expression to emit");
788 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag)
789 .Visit(const_cast<Expr*>(E));
792 /// EmitComplexExprIntoAddr - Emit the computation of the specified expression
793 /// of complex type, storing into the specified Value*.
794 void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E,
795 llvm::Value *DestAddr,
796 bool DestIsVolatile) {
797 assert(E && E->getType()->isAnyComplexType() &&
798 "Invalid complex expression to emit");
799 ComplexExprEmitter Emitter(*this);
800 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E));
801 Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile);
804 /// StoreComplexToAddr - Store a complex number into the specified address.
805 void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V,
806 llvm::Value *DestAddr,
807 bool DestIsVolatile) {
808 ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile);
811 /// LoadComplexFromAddr - Load a complex number from the specified address.
812 ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr,
813 bool SrcIsVolatile) {
814 return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile);
817 LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) {
818 assert(E->getOpcode() == BO_Assign);
819 ComplexPairTy Val; // ignored
820 return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val);
823 LValue CodeGenFunction::
824 EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) {
825 ComplexPairTy(ComplexExprEmitter::*Op)(const ComplexExprEmitter::BinOpInfo &);
826 switch (E->getOpcode()) {
827 case BO_MulAssign: Op = &ComplexExprEmitter::EmitBinMul; break;
828 case BO_DivAssign: Op = &ComplexExprEmitter::EmitBinDiv; break;
829 case BO_SubAssign: Op = &ComplexExprEmitter::EmitBinSub; break;
830 case BO_AddAssign: Op = &ComplexExprEmitter::EmitBinAdd; break;
833 llvm_unreachable("unexpected complex compound assignment");
837 ComplexPairTy Val; // ignored
838 return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);