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/ADT/SmallString.h"
19 #include "llvm/IR/Constants.h"
20 #include "llvm/IR/Function.h"
21 using namespace clang;
22 using namespace CodeGen;
24 //===----------------------------------------------------------------------===//
25 // Complex Expression Emitter
26 //===----------------------------------------------------------------------===//
28 typedef CodeGenFunction::ComplexPairTy ComplexPairTy;
30 /// Return the complex type that we are meant to emit.
31 static const ComplexType *getComplexType(QualType type) {
32 type = type.getCanonicalType();
33 if (const ComplexType *comp = dyn_cast<ComplexType>(type)) {
36 return cast<ComplexType>(cast<AtomicType>(type)->getValueType());
41 class ComplexExprEmitter
42 : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> {
48 ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false)
49 : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) {
53 //===--------------------------------------------------------------------===//
55 //===--------------------------------------------------------------------===//
57 bool TestAndClearIgnoreReal() {
62 bool TestAndClearIgnoreImag() {
68 /// EmitLoadOfLValue - Given an expression with complex type that represents a
69 /// value l-value, this method emits the address of the l-value, then loads
70 /// and returns the result.
71 ComplexPairTy EmitLoadOfLValue(const Expr *E) {
72 return EmitLoadOfLValue(CGF.EmitLValue(E));
75 ComplexPairTy EmitLoadOfLValue(LValue LV);
77 /// EmitStoreOfComplex - Store the specified real/imag parts into the
78 /// specified value pointer.
79 void EmitStoreOfComplex(ComplexPairTy Val, LValue LV, bool isInit);
81 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
82 ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType,
85 //===--------------------------------------------------------------------===//
87 //===--------------------------------------------------------------------===//
89 ComplexPairTy Visit(Expr *E) {
90 return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E);
93 ComplexPairTy VisitStmt(Stmt *S) {
94 S->dump(CGF.getContext().getSourceManager());
95 llvm_unreachable("Stmt can't have complex result type!");
97 ComplexPairTy VisitExpr(Expr *S);
98 ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
99 ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
100 return Visit(GE->getResultExpr());
102 ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL);
104 VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
105 return Visit(PE->getReplacement());
109 ComplexPairTy VisitDeclRefExpr(DeclRefExpr *E) {
110 if (CodeGenFunction::ConstantEmission result = CGF.tryEmitAsConstant(E)) {
111 if (result.isReference())
112 return EmitLoadOfLValue(result.getReferenceLValue(CGF, E));
114 llvm::ConstantStruct *pair =
115 cast<llvm::ConstantStruct>(result.getValue());
116 return ComplexPairTy(pair->getOperand(0), pair->getOperand(1));
118 return EmitLoadOfLValue(E);
120 ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
121 return EmitLoadOfLValue(E);
123 ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) {
124 return CGF.EmitObjCMessageExpr(E).getComplexVal();
126 ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); }
127 ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); }
128 ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) {
130 return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E));
131 return CGF.getOpaqueRValueMapping(E).getComplexVal();
134 ComplexPairTy VisitPseudoObjectExpr(PseudoObjectExpr *E) {
135 return CGF.EmitPseudoObjectRValue(E).getComplexVal();
138 // FIXME: CompoundLiteralExpr
140 ComplexPairTy EmitCast(CastExpr::CastKind CK, Expr *Op, QualType DestTy);
141 ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) {
142 // Unlike for scalars, we don't have to worry about function->ptr demotion
144 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
146 ComplexPairTy VisitCastExpr(CastExpr *E) {
147 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
149 ComplexPairTy VisitCallExpr(const CallExpr *E);
150 ComplexPairTy VisitStmtExpr(const StmtExpr *E);
153 ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E,
154 bool isInc, bool isPre) {
155 LValue LV = CGF.EmitLValue(E->getSubExpr());
156 return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre);
158 ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) {
159 return VisitPrePostIncDec(E, false, false);
161 ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) {
162 return VisitPrePostIncDec(E, true, false);
164 ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) {
165 return VisitPrePostIncDec(E, false, true);
167 ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) {
168 return VisitPrePostIncDec(E, true, true);
170 ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
171 ComplexPairTy VisitUnaryPlus (const UnaryOperator *E) {
172 TestAndClearIgnoreReal();
173 TestAndClearIgnoreImag();
174 return Visit(E->getSubExpr());
176 ComplexPairTy VisitUnaryMinus (const UnaryOperator *E);
177 ComplexPairTy VisitUnaryNot (const UnaryOperator *E);
178 // LNot,Real,Imag never return complex.
179 ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) {
180 return Visit(E->getSubExpr());
182 ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
183 return Visit(DAE->getExpr());
185 ComplexPairTy VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
186 CodeGenFunction::CXXDefaultInitExprScope Scope(CGF);
187 return Visit(DIE->getExpr());
189 ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) {
190 CGF.enterFullExpression(E);
191 CodeGenFunction::RunCleanupsScope Scope(CGF);
192 return Visit(E->getSubExpr());
194 ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
195 assert(E->getType()->isAnyComplexType() && "Expected complex type!");
196 QualType Elem = E->getType()->castAs<ComplexType>()->getElementType();
197 llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem));
198 return ComplexPairTy(Null, Null);
200 ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
201 assert(E->getType()->isAnyComplexType() && "Expected complex type!");
202 QualType Elem = E->getType()->castAs<ComplexType>()->getElementType();
203 llvm::Constant *Null =
204 llvm::Constant::getNullValue(CGF.ConvertType(Elem));
205 return ComplexPairTy(Null, Null);
211 QualType Ty; // Computation Type.
214 BinOpInfo EmitBinOps(const BinaryOperator *E);
215 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
216 ComplexPairTy (ComplexExprEmitter::*Func)
219 ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E,
220 ComplexPairTy (ComplexExprEmitter::*Func)
221 (const BinOpInfo &));
223 ComplexPairTy EmitBinAdd(const BinOpInfo &Op);
224 ComplexPairTy EmitBinSub(const BinOpInfo &Op);
225 ComplexPairTy EmitBinMul(const BinOpInfo &Op);
226 ComplexPairTy EmitBinDiv(const BinOpInfo &Op);
228 ComplexPairTy VisitBinAdd(const BinaryOperator *E) {
229 return EmitBinAdd(EmitBinOps(E));
231 ComplexPairTy VisitBinSub(const BinaryOperator *E) {
232 return EmitBinSub(EmitBinOps(E));
234 ComplexPairTy VisitBinMul(const BinaryOperator *E) {
235 return EmitBinMul(EmitBinOps(E));
237 ComplexPairTy VisitBinDiv(const BinaryOperator *E) {
238 return EmitBinDiv(EmitBinOps(E));
241 // Compound assignments.
242 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) {
243 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd);
245 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) {
246 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub);
248 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) {
249 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul);
251 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) {
252 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv);
255 // GCC rejects rem/and/or/xor for integer complex.
256 // Logical and/or always return int, never complex.
258 // No comparisons produce a complex result.
260 LValue EmitBinAssignLValue(const BinaryOperator *E,
262 ComplexPairTy VisitBinAssign (const BinaryOperator *E);
263 ComplexPairTy VisitBinComma (const BinaryOperator *E);
267 VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
268 ComplexPairTy VisitChooseExpr(ChooseExpr *CE);
270 ComplexPairTy VisitInitListExpr(InitListExpr *E);
272 ComplexPairTy VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
273 return EmitLoadOfLValue(E);
276 ComplexPairTy VisitVAArgExpr(VAArgExpr *E);
278 ComplexPairTy VisitAtomicExpr(AtomicExpr *E) {
279 return CGF.EmitAtomicExpr(E).getComplexVal();
282 } // end anonymous namespace.
284 //===----------------------------------------------------------------------===//
286 //===----------------------------------------------------------------------===//
288 /// EmitLoadOfLValue - Given an RValue reference for a complex, emit code to
289 /// load the real and imaginary pieces, returning them as Real/Imag.
290 ComplexPairTy ComplexExprEmitter::EmitLoadOfLValue(LValue lvalue) {
291 assert(lvalue.isSimple() && "non-simple complex l-value?");
292 if (lvalue.getType()->isAtomicType())
293 return CGF.EmitAtomicLoad(lvalue).getComplexVal();
295 llvm::Value *SrcPtr = lvalue.getAddress();
296 bool isVolatile = lvalue.isVolatileQualified();
298 llvm::Value *Real=0, *Imag=0;
300 if (!IgnoreReal || isVolatile) {
301 llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0,
302 SrcPtr->getName() + ".realp");
303 Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr->getName() + ".real");
306 if (!IgnoreImag || isVolatile) {
307 llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1,
308 SrcPtr->getName() + ".imagp");
309 Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr->getName() + ".imag");
311 return ComplexPairTy(Real, Imag);
314 /// EmitStoreOfComplex - Store the specified real/imag parts into the
315 /// specified value pointer.
316 void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val,
319 if (lvalue.getType()->isAtomicType())
320 return CGF.EmitAtomicStore(RValue::getComplex(Val), lvalue, isInit);
322 llvm::Value *Ptr = lvalue.getAddress();
323 llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real");
324 llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag");
327 Builder.CreateStore(Val.first, RealPtr, lvalue.isVolatileQualified());
328 Builder.CreateStore(Val.second, ImagPtr, lvalue.isVolatileQualified());
333 //===----------------------------------------------------------------------===//
335 //===----------------------------------------------------------------------===//
337 ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
338 CGF.ErrorUnsupported(E, "complex expression");
340 CGF.ConvertType(getComplexType(E->getType())->getElementType());
341 llvm::Value *U = llvm::UndefValue::get(EltTy);
342 return ComplexPairTy(U, U);
345 ComplexPairTy ComplexExprEmitter::
346 VisitImaginaryLiteral(const ImaginaryLiteral *IL) {
347 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr());
348 return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag);
352 ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
353 if (E->getCallReturnType()->isReferenceType())
354 return EmitLoadOfLValue(E);
356 return CGF.EmitCallExpr(E).getComplexVal();
359 ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) {
360 CodeGenFunction::StmtExprEvaluation eval(CGF);
361 return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal();
364 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType.
365 ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val,
368 // Get the src/dest element type.
369 SrcType = SrcType->castAs<ComplexType>()->getElementType();
370 DestType = DestType->castAs<ComplexType>()->getElementType();
372 // C99 6.3.1.6: When a value of complex type is converted to another
373 // complex type, both the real and imaginary parts follow the conversion
374 // rules for the corresponding real types.
375 Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType);
376 Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType);
380 ComplexPairTy ComplexExprEmitter::EmitCast(CastExpr::CastKind CK, Expr *Op,
383 case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!");
385 // Atomic to non-atomic casts may be more than a no-op for some platforms and
387 case CK_AtomicToNonAtomic:
388 case CK_NonAtomicToAtomic:
390 case CK_LValueToRValue:
391 case CK_UserDefinedConversion:
394 case CK_LValueBitCast: {
395 LValue origLV = CGF.EmitLValue(Op);
396 llvm::Value *V = origLV.getAddress();
397 V = Builder.CreateBitCast(V,
398 CGF.ConvertType(CGF.getContext().getPointerType(DestTy)));
399 return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy,
400 origLV.getAlignment()));
404 case CK_BaseToDerived:
405 case CK_DerivedToBase:
406 case CK_UncheckedDerivedToBase:
409 case CK_ArrayToPointerDecay:
410 case CK_FunctionToPointerDecay:
411 case CK_NullToPointer:
412 case CK_NullToMemberPointer:
413 case CK_BaseToDerivedMemberPointer:
414 case CK_DerivedToBaseMemberPointer:
415 case CK_MemberPointerToBoolean:
416 case CK_ReinterpretMemberPointer:
417 case CK_ConstructorConversion:
418 case CK_IntegralToPointer:
419 case CK_PointerToIntegral:
420 case CK_PointerToBoolean:
423 case CK_IntegralCast:
424 case CK_IntegralToBoolean:
425 case CK_IntegralToFloating:
426 case CK_FloatingToIntegral:
427 case CK_FloatingToBoolean:
428 case CK_FloatingCast:
429 case CK_CPointerToObjCPointerCast:
430 case CK_BlockPointerToObjCPointerCast:
431 case CK_AnyPointerToBlockPointerCast:
432 case CK_ObjCObjectLValueCast:
433 case CK_FloatingComplexToReal:
434 case CK_FloatingComplexToBoolean:
435 case CK_IntegralComplexToReal:
436 case CK_IntegralComplexToBoolean:
437 case CK_ARCProduceObject:
438 case CK_ARCConsumeObject:
439 case CK_ARCReclaimReturnedObject:
440 case CK_ARCExtendBlockObject:
441 case CK_CopyAndAutoreleaseBlockObject:
442 case CK_BuiltinFnToFnPtr:
443 case CK_ZeroToOCLEvent:
444 llvm_unreachable("invalid cast kind for complex value");
446 case CK_FloatingRealToComplex:
447 case CK_IntegralRealToComplex: {
448 llvm::Value *Elt = CGF.EmitScalarExpr(Op);
450 // Convert the input element to the element type of the complex.
451 DestTy = DestTy->castAs<ComplexType>()->getElementType();
452 Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy);
454 // Return (realval, 0).
455 return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType()));
458 case CK_FloatingComplexCast:
459 case CK_FloatingComplexToIntegralComplex:
460 case CK_IntegralComplexCast:
461 case CK_IntegralComplexToFloatingComplex:
462 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy);
465 llvm_unreachable("unknown cast resulting in complex value");
468 ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
469 TestAndClearIgnoreReal();
470 TestAndClearIgnoreImag();
471 ComplexPairTy Op = Visit(E->getSubExpr());
473 llvm::Value *ResR, *ResI;
474 if (Op.first->getType()->isFloatingPointTy()) {
475 ResR = Builder.CreateFNeg(Op.first, "neg.r");
476 ResI = Builder.CreateFNeg(Op.second, "neg.i");
478 ResR = Builder.CreateNeg(Op.first, "neg.r");
479 ResI = Builder.CreateNeg(Op.second, "neg.i");
481 return ComplexPairTy(ResR, ResI);
484 ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
485 TestAndClearIgnoreReal();
486 TestAndClearIgnoreImag();
487 // ~(a+ib) = a + i*-b
488 ComplexPairTy Op = Visit(E->getSubExpr());
490 if (Op.second->getType()->isFloatingPointTy())
491 ResI = Builder.CreateFNeg(Op.second, "conj.i");
493 ResI = Builder.CreateNeg(Op.second, "conj.i");
495 return ComplexPairTy(Op.first, ResI);
498 ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) {
499 llvm::Value *ResR, *ResI;
501 if (Op.LHS.first->getType()->isFloatingPointTy()) {
502 ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r");
503 ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i");
505 ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r");
506 ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i");
508 return ComplexPairTy(ResR, ResI);
511 ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) {
512 llvm::Value *ResR, *ResI;
513 if (Op.LHS.first->getType()->isFloatingPointTy()) {
514 ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r");
515 ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i");
517 ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r");
518 ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i");
520 return ComplexPairTy(ResR, ResI);
524 ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) {
528 if (Op.LHS.first->getType()->isFloatingPointTy()) {
529 Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl");
530 Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr");
531 ResR = Builder.CreateFSub(ResRl, ResRr, "mul.r");
533 Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il");
534 Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir");
535 ResI = Builder.CreateFAdd(ResIl, ResIr, "mul.i");
537 Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl");
538 Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr");
539 ResR = Builder.CreateSub(ResRl, ResRr, "mul.r");
541 Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il");
542 Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir");
543 ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i");
545 return ComplexPairTy(ResR, ResI);
548 ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) {
549 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
550 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
553 llvm::Value *DSTr, *DSTi;
554 if (Op.LHS.first->getType()->isFloatingPointTy()) {
555 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
556 llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr); // a*c
557 llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi); // b*d
558 llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2); // ac+bd
560 llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr); // c*c
561 llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi); // d*d
562 llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5); // cc+dd
564 llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr); // b*c
565 llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi); // a*d
566 llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8); // bc-ad
568 DSTr = Builder.CreateFDiv(Tmp3, Tmp6);
569 DSTi = Builder.CreateFDiv(Tmp9, Tmp6);
571 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
572 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c
573 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d
574 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd
576 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c
577 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d
578 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd
580 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c
581 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d
582 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad
584 if (Op.Ty->castAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) {
585 DSTr = Builder.CreateUDiv(Tmp3, Tmp6);
586 DSTi = Builder.CreateUDiv(Tmp9, Tmp6);
588 DSTr = Builder.CreateSDiv(Tmp3, Tmp6);
589 DSTi = Builder.CreateSDiv(Tmp9, Tmp6);
593 return ComplexPairTy(DSTr, DSTi);
596 ComplexExprEmitter::BinOpInfo
597 ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) {
598 TestAndClearIgnoreReal();
599 TestAndClearIgnoreImag();
601 Ops.LHS = Visit(E->getLHS());
602 Ops.RHS = Visit(E->getRHS());
603 Ops.Ty = E->getType();
608 LValue ComplexExprEmitter::
609 EmitCompoundAssignLValue(const CompoundAssignOperator *E,
610 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&),
611 ComplexPairTy &Val) {
612 TestAndClearIgnoreReal();
613 TestAndClearIgnoreImag();
614 QualType LHSTy = E->getLHS()->getType();
618 // Load the RHS and LHS operands.
619 // __block variables need to have the rhs evaluated first, plus this should
620 // improve codegen a little.
621 OpInfo.Ty = E->getComputationResultType();
623 // The RHS should have been converted to the computation type.
624 assert(OpInfo.Ty->isAnyComplexType());
625 assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty,
626 E->getRHS()->getType()));
627 OpInfo.RHS = Visit(E->getRHS());
629 LValue LHS = CGF.EmitLValue(E->getLHS());
631 // Load from the l-value.
632 ComplexPairTy LHSComplexPair = EmitLoadOfLValue(LHS);
634 OpInfo.LHS = EmitComplexToComplexCast(LHSComplexPair, LHSTy, OpInfo.Ty);
636 // Expand the binary operator.
637 ComplexPairTy Result = (this->*Func)(OpInfo);
639 // Truncate the result back to the LHS type.
640 Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy);
643 // Store the result value into the LHS lvalue.
644 EmitStoreOfComplex(Result, LHS, /*isInit*/ false);
649 // Compound assignments.
650 ComplexPairTy ComplexExprEmitter::
651 EmitCompoundAssign(const CompoundAssignOperator *E,
652 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){
654 LValue LV = EmitCompoundAssignLValue(E, Func, Val);
656 // The result of an assignment in C is the assigned r-value.
657 if (!CGF.getLangOpts().CPlusPlus)
660 // If the lvalue is non-volatile, return the computed value of the assignment.
661 if (!LV.isVolatileQualified())
664 return EmitLoadOfLValue(LV);
667 LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E,
668 ComplexPairTy &Val) {
669 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
670 E->getRHS()->getType()) &&
671 "Invalid assignment");
672 TestAndClearIgnoreReal();
673 TestAndClearIgnoreImag();
675 // Emit the RHS. __block variables need the RHS evaluated first.
676 Val = Visit(E->getRHS());
678 // Compute the address to store into.
679 LValue LHS = CGF.EmitLValue(E->getLHS());
681 // Store the result value into the LHS lvalue.
682 EmitStoreOfComplex(Val, LHS, /*isInit*/ false);
687 ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
689 LValue LV = EmitBinAssignLValue(E, Val);
691 // The result of an assignment in C is the assigned r-value.
692 if (!CGF.getLangOpts().CPlusPlus)
695 // If the lvalue is non-volatile, return the computed value of the assignment.
696 if (!LV.isVolatileQualified())
699 return EmitLoadOfLValue(LV);
702 ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) {
703 CGF.EmitIgnoredExpr(E->getLHS());
704 return Visit(E->getRHS());
707 ComplexPairTy ComplexExprEmitter::
708 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
709 TestAndClearIgnoreReal();
710 TestAndClearIgnoreImag();
711 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
712 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
713 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
715 // Bind the common expression if necessary.
716 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
718 CodeGenFunction::ConditionalEvaluation eval(CGF);
719 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock);
722 CGF.EmitBlock(LHSBlock);
723 ComplexPairTy LHS = Visit(E->getTrueExpr());
724 LHSBlock = Builder.GetInsertBlock();
725 CGF.EmitBranch(ContBlock);
729 CGF.EmitBlock(RHSBlock);
730 ComplexPairTy RHS = Visit(E->getFalseExpr());
731 RHSBlock = Builder.GetInsertBlock();
732 CGF.EmitBlock(ContBlock);
735 // Create a PHI node for the real part.
736 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r");
737 RealPN->addIncoming(LHS.first, LHSBlock);
738 RealPN->addIncoming(RHS.first, RHSBlock);
740 // Create a PHI node for the imaginary part.
741 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i");
742 ImagPN->addIncoming(LHS.second, LHSBlock);
743 ImagPN->addIncoming(RHS.second, RHSBlock);
745 return ComplexPairTy(RealPN, ImagPN);
748 ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) {
749 return Visit(E->getChosenSubExpr(CGF.getContext()));
752 ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
753 bool Ignore = TestAndClearIgnoreReal();
755 assert (Ignore == false && "init list ignored");
756 Ignore = TestAndClearIgnoreImag();
758 assert (Ignore == false && "init list ignored");
760 if (E->getNumInits() == 2) {
761 llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0));
762 llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1));
763 return ComplexPairTy(Real, Imag);
764 } else if (E->getNumInits() == 1) {
765 return Visit(E->getInit(0));
768 // Empty init list intializes to null
769 assert(E->getNumInits() == 0 && "Unexpected number of inits");
770 QualType Ty = E->getType()->castAs<ComplexType>()->getElementType();
771 llvm::Type* LTy = CGF.ConvertType(Ty);
772 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
773 return ComplexPairTy(zeroConstant, zeroConstant);
776 ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
777 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr());
778 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType());
781 CGF.ErrorUnsupported(E, "complex va_arg expression");
783 CGF.ConvertType(E->getType()->castAs<ComplexType>()->getElementType());
784 llvm::Value *U = llvm::UndefValue::get(EltTy);
785 return ComplexPairTy(U, U);
788 return EmitLoadOfLValue(
789 CGF.MakeNaturalAlignAddrLValue(ArgPtr, E->getType()));
792 //===----------------------------------------------------------------------===//
793 // Entry Point into this File
794 //===----------------------------------------------------------------------===//
796 /// EmitComplexExpr - Emit the computation of the specified expression of
797 /// complex type, ignoring the result.
798 ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal,
800 assert(E && getComplexType(E->getType()) &&
801 "Invalid complex expression to emit");
803 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag)
804 .Visit(const_cast<Expr*>(E));
807 void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest,
809 assert(E && getComplexType(E->getType()) &&
810 "Invalid complex expression to emit");
811 ComplexExprEmitter Emitter(*this);
812 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E));
813 Emitter.EmitStoreOfComplex(Val, dest, isInit);
816 /// EmitStoreOfComplex - Store a complex number into the specified l-value.
817 void CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue dest,
819 ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit);
822 /// EmitLoadOfComplex - Load a complex number from the specified address.
823 ComplexPairTy CodeGenFunction::EmitLoadOfComplex(LValue src) {
824 return ComplexExprEmitter(*this).EmitLoadOfLValue(src);
827 LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) {
828 assert(E->getOpcode() == BO_Assign);
829 ComplexPairTy Val; // ignored
830 return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val);
833 LValue CodeGenFunction::
834 EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) {
835 ComplexPairTy(ComplexExprEmitter::*Op)(const ComplexExprEmitter::BinOpInfo &);
836 switch (E->getOpcode()) {
837 case BO_MulAssign: Op = &ComplexExprEmitter::EmitBinMul; break;
838 case BO_DivAssign: Op = &ComplexExprEmitter::EmitBinDiv; break;
839 case BO_SubAssign: Op = &ComplexExprEmitter::EmitBinSub; break;
840 case BO_AddAssign: Op = &ComplexExprEmitter::EmitBinAdd; break;
843 llvm_unreachable("unexpected complex compound assignment");
846 ComplexPairTy Val; // ignored
847 return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);