10b57cec5SDimitry Andric //===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===//
20b57cec5SDimitry Andric //
30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information.
50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
60b57cec5SDimitry Andric //
70b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
80b57cec5SDimitry Andric //
90b57cec5SDimitry Andric // This contains code to emit Expr nodes with complex types as LLVM code.
100b57cec5SDimitry Andric //
110b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
120b57cec5SDimitry Andric
13480093f4SDimitry Andric #include "CGOpenMPRuntime.h"
140b57cec5SDimitry Andric #include "CodeGenFunction.h"
150b57cec5SDimitry Andric #include "CodeGenModule.h"
165ffd83dbSDimitry Andric #include "ConstantEmitter.h"
170b57cec5SDimitry Andric #include "clang/AST/StmtVisitor.h"
180b57cec5SDimitry Andric #include "llvm/ADT/STLExtras.h"
190b57cec5SDimitry Andric #include "llvm/IR/Constants.h"
200b57cec5SDimitry Andric #include "llvm/IR/Instructions.h"
210b57cec5SDimitry Andric #include "llvm/IR/MDBuilder.h"
220b57cec5SDimitry Andric #include "llvm/IR/Metadata.h"
230b57cec5SDimitry Andric #include <algorithm>
240b57cec5SDimitry Andric using namespace clang;
250b57cec5SDimitry Andric using namespace CodeGen;
260b57cec5SDimitry Andric
270b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
280b57cec5SDimitry Andric // Complex Expression Emitter
290b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
300b57cec5SDimitry Andric
310b57cec5SDimitry Andric typedef CodeGenFunction::ComplexPairTy ComplexPairTy;
320b57cec5SDimitry Andric
330b57cec5SDimitry Andric /// Return the complex type that we are meant to emit.
getComplexType(QualType type)340b57cec5SDimitry Andric static const ComplexType *getComplexType(QualType type) {
350b57cec5SDimitry Andric type = type.getCanonicalType();
360b57cec5SDimitry Andric if (const ComplexType *comp = dyn_cast<ComplexType>(type)) {
370b57cec5SDimitry Andric return comp;
380b57cec5SDimitry Andric } else {
390b57cec5SDimitry Andric return cast<ComplexType>(cast<AtomicType>(type)->getValueType());
400b57cec5SDimitry Andric }
410b57cec5SDimitry Andric }
420b57cec5SDimitry Andric
430b57cec5SDimitry Andric namespace {
440b57cec5SDimitry Andric class ComplexExprEmitter
450b57cec5SDimitry Andric : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> {
460b57cec5SDimitry Andric CodeGenFunction &CGF;
470b57cec5SDimitry Andric CGBuilderTy &Builder;
480b57cec5SDimitry Andric bool IgnoreReal;
490b57cec5SDimitry Andric bool IgnoreImag;
500b57cec5SDimitry Andric public:
ComplexExprEmitter(CodeGenFunction & cgf,bool ir=false,bool ii=false)510b57cec5SDimitry Andric ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false)
520b57cec5SDimitry Andric : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) {
530b57cec5SDimitry Andric }
540b57cec5SDimitry Andric
550b57cec5SDimitry Andric
560b57cec5SDimitry Andric //===--------------------------------------------------------------------===//
570b57cec5SDimitry Andric // Utilities
580b57cec5SDimitry Andric //===--------------------------------------------------------------------===//
590b57cec5SDimitry Andric
TestAndClearIgnoreReal()600b57cec5SDimitry Andric bool TestAndClearIgnoreReal() {
610b57cec5SDimitry Andric bool I = IgnoreReal;
620b57cec5SDimitry Andric IgnoreReal = false;
630b57cec5SDimitry Andric return I;
640b57cec5SDimitry Andric }
TestAndClearIgnoreImag()650b57cec5SDimitry Andric bool TestAndClearIgnoreImag() {
660b57cec5SDimitry Andric bool I = IgnoreImag;
670b57cec5SDimitry Andric IgnoreImag = false;
680b57cec5SDimitry Andric return I;
690b57cec5SDimitry Andric }
700b57cec5SDimitry Andric
710b57cec5SDimitry Andric /// EmitLoadOfLValue - Given an expression with complex type that represents a
720b57cec5SDimitry Andric /// value l-value, this method emits the address of the l-value, then loads
730b57cec5SDimitry Andric /// and returns the result.
EmitLoadOfLValue(const Expr * E)740b57cec5SDimitry Andric ComplexPairTy EmitLoadOfLValue(const Expr *E) {
750b57cec5SDimitry Andric return EmitLoadOfLValue(CGF.EmitLValue(E), E->getExprLoc());
760b57cec5SDimitry Andric }
770b57cec5SDimitry Andric
780b57cec5SDimitry Andric ComplexPairTy EmitLoadOfLValue(LValue LV, SourceLocation Loc);
790b57cec5SDimitry Andric
800b57cec5SDimitry Andric /// EmitStoreOfComplex - Store the specified real/imag parts into the
810b57cec5SDimitry Andric /// specified value pointer.
820b57cec5SDimitry Andric void EmitStoreOfComplex(ComplexPairTy Val, LValue LV, bool isInit);
830b57cec5SDimitry Andric
840b57cec5SDimitry Andric /// Emit a cast from complex value Val to DestType.
850b57cec5SDimitry Andric ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType,
860b57cec5SDimitry Andric QualType DestType, SourceLocation Loc);
870b57cec5SDimitry Andric /// Emit a cast from scalar value Val to DestType.
880b57cec5SDimitry Andric ComplexPairTy EmitScalarToComplexCast(llvm::Value *Val, QualType SrcType,
890b57cec5SDimitry Andric QualType DestType, SourceLocation Loc);
900b57cec5SDimitry Andric
910b57cec5SDimitry Andric //===--------------------------------------------------------------------===//
920b57cec5SDimitry Andric // Visitor Methods
930b57cec5SDimitry Andric //===--------------------------------------------------------------------===//
940b57cec5SDimitry Andric
Visit(Expr * E)950b57cec5SDimitry Andric ComplexPairTy Visit(Expr *E) {
960b57cec5SDimitry Andric ApplyDebugLocation DL(CGF, E);
970b57cec5SDimitry Andric return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E);
980b57cec5SDimitry Andric }
990b57cec5SDimitry Andric
VisitStmt(Stmt * S)1000b57cec5SDimitry Andric ComplexPairTy VisitStmt(Stmt *S) {
1015ffd83dbSDimitry Andric S->dump(llvm::errs(), CGF.getContext());
1020b57cec5SDimitry Andric llvm_unreachable("Stmt can't have complex result type!");
1030b57cec5SDimitry Andric }
1040b57cec5SDimitry Andric ComplexPairTy VisitExpr(Expr *S);
VisitConstantExpr(ConstantExpr * E)1050b57cec5SDimitry Andric ComplexPairTy VisitConstantExpr(ConstantExpr *E) {
1065ffd83dbSDimitry Andric if (llvm::Constant *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E))
1075ffd83dbSDimitry Andric return ComplexPairTy(Result->getAggregateElement(0U),
1085ffd83dbSDimitry Andric Result->getAggregateElement(1U));
1090b57cec5SDimitry Andric return Visit(E->getSubExpr());
1100b57cec5SDimitry Andric }
VisitParenExpr(ParenExpr * PE)1110b57cec5SDimitry Andric ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());}
VisitGenericSelectionExpr(GenericSelectionExpr * GE)1120b57cec5SDimitry Andric ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
1130b57cec5SDimitry Andric return Visit(GE->getResultExpr());
1140b57cec5SDimitry Andric }
1150b57cec5SDimitry Andric ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL);
1160b57cec5SDimitry Andric ComplexPairTy
VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr * PE)1170b57cec5SDimitry Andric VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
1180b57cec5SDimitry Andric return Visit(PE->getReplacement());
1190b57cec5SDimitry Andric }
VisitCoawaitExpr(CoawaitExpr * S)1200b57cec5SDimitry Andric ComplexPairTy VisitCoawaitExpr(CoawaitExpr *S) {
1210b57cec5SDimitry Andric return CGF.EmitCoawaitExpr(*S).getComplexVal();
1220b57cec5SDimitry Andric }
VisitCoyieldExpr(CoyieldExpr * S)1230b57cec5SDimitry Andric ComplexPairTy VisitCoyieldExpr(CoyieldExpr *S) {
1240b57cec5SDimitry Andric return CGF.EmitCoyieldExpr(*S).getComplexVal();
1250b57cec5SDimitry Andric }
VisitUnaryCoawait(const UnaryOperator * E)1260b57cec5SDimitry Andric ComplexPairTy VisitUnaryCoawait(const UnaryOperator *E) {
1270b57cec5SDimitry Andric return Visit(E->getSubExpr());
1280b57cec5SDimitry Andric }
1290b57cec5SDimitry Andric
emitConstant(const CodeGenFunction::ConstantEmission & Constant,Expr * E)1300b57cec5SDimitry Andric ComplexPairTy emitConstant(const CodeGenFunction::ConstantEmission &Constant,
1310b57cec5SDimitry Andric Expr *E) {
1320b57cec5SDimitry Andric assert(Constant && "not a constant");
1330b57cec5SDimitry Andric if (Constant.isReference())
1340b57cec5SDimitry Andric return EmitLoadOfLValue(Constant.getReferenceLValue(CGF, E),
1350b57cec5SDimitry Andric E->getExprLoc());
1360b57cec5SDimitry Andric
1370b57cec5SDimitry Andric llvm::Constant *pair = Constant.getValue();
1380b57cec5SDimitry Andric return ComplexPairTy(pair->getAggregateElement(0U),
1390b57cec5SDimitry Andric pair->getAggregateElement(1U));
1400b57cec5SDimitry Andric }
1410b57cec5SDimitry Andric
1420b57cec5SDimitry Andric // l-values.
VisitDeclRefExpr(DeclRefExpr * E)1430b57cec5SDimitry Andric ComplexPairTy VisitDeclRefExpr(DeclRefExpr *E) {
1440b57cec5SDimitry Andric if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E))
1450b57cec5SDimitry Andric return emitConstant(Constant, E);
1460b57cec5SDimitry Andric return EmitLoadOfLValue(E);
1470b57cec5SDimitry Andric }
VisitObjCIvarRefExpr(ObjCIvarRefExpr * E)1480b57cec5SDimitry Andric ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1490b57cec5SDimitry Andric return EmitLoadOfLValue(E);
1500b57cec5SDimitry Andric }
VisitObjCMessageExpr(ObjCMessageExpr * E)1510b57cec5SDimitry Andric ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) {
1520b57cec5SDimitry Andric return CGF.EmitObjCMessageExpr(E).getComplexVal();
1530b57cec5SDimitry Andric }
VisitArraySubscriptExpr(Expr * E)1540b57cec5SDimitry Andric ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); }
VisitMemberExpr(MemberExpr * ME)1550b57cec5SDimitry Andric ComplexPairTy VisitMemberExpr(MemberExpr *ME) {
1560b57cec5SDimitry Andric if (CodeGenFunction::ConstantEmission Constant =
1570b57cec5SDimitry Andric CGF.tryEmitAsConstant(ME)) {
1580b57cec5SDimitry Andric CGF.EmitIgnoredExpr(ME->getBase());
1590b57cec5SDimitry Andric return emitConstant(Constant, ME);
1600b57cec5SDimitry Andric }
1610b57cec5SDimitry Andric return EmitLoadOfLValue(ME);
1620b57cec5SDimitry Andric }
VisitOpaqueValueExpr(OpaqueValueExpr * E)1630b57cec5SDimitry Andric ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1640b57cec5SDimitry Andric if (E->isGLValue())
1650b57cec5SDimitry Andric return EmitLoadOfLValue(CGF.getOrCreateOpaqueLValueMapping(E),
1660b57cec5SDimitry Andric E->getExprLoc());
1670b57cec5SDimitry Andric return CGF.getOrCreateOpaqueRValueMapping(E).getComplexVal();
1680b57cec5SDimitry Andric }
1690b57cec5SDimitry Andric
VisitPseudoObjectExpr(PseudoObjectExpr * E)1700b57cec5SDimitry Andric ComplexPairTy VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1710b57cec5SDimitry Andric return CGF.EmitPseudoObjectRValue(E).getComplexVal();
1720b57cec5SDimitry Andric }
1730b57cec5SDimitry Andric
1740b57cec5SDimitry Andric // FIXME: CompoundLiteralExpr
1750b57cec5SDimitry Andric
1760b57cec5SDimitry Andric ComplexPairTy EmitCast(CastKind CK, Expr *Op, QualType DestTy);
VisitImplicitCastExpr(ImplicitCastExpr * E)1770b57cec5SDimitry Andric ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) {
1780b57cec5SDimitry Andric // Unlike for scalars, we don't have to worry about function->ptr demotion
1790b57cec5SDimitry Andric // here.
1805f757f3fSDimitry Andric if (E->changesVolatileQualification())
1815f757f3fSDimitry Andric return EmitLoadOfLValue(E);
1820b57cec5SDimitry Andric return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
1830b57cec5SDimitry Andric }
VisitCastExpr(CastExpr * E)1840b57cec5SDimitry Andric ComplexPairTy VisitCastExpr(CastExpr *E) {
1850b57cec5SDimitry Andric if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
1860b57cec5SDimitry Andric CGF.CGM.EmitExplicitCastExprType(ECE, &CGF);
1875f757f3fSDimitry Andric if (E->changesVolatileQualification())
1885f757f3fSDimitry Andric return EmitLoadOfLValue(E);
1890b57cec5SDimitry Andric return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType());
1900b57cec5SDimitry Andric }
1910b57cec5SDimitry Andric ComplexPairTy VisitCallExpr(const CallExpr *E);
1920b57cec5SDimitry Andric ComplexPairTy VisitStmtExpr(const StmtExpr *E);
1930b57cec5SDimitry Andric
1940b57cec5SDimitry Andric // Operators.
VisitPrePostIncDec(const UnaryOperator * E,bool isInc,bool isPre)1950b57cec5SDimitry Andric ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E,
1960b57cec5SDimitry Andric bool isInc, bool isPre) {
1970b57cec5SDimitry Andric LValue LV = CGF.EmitLValue(E->getSubExpr());
1980b57cec5SDimitry Andric return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre);
1990b57cec5SDimitry Andric }
VisitUnaryPostDec(const UnaryOperator * E)2000b57cec5SDimitry Andric ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) {
2010b57cec5SDimitry Andric return VisitPrePostIncDec(E, false, false);
2020b57cec5SDimitry Andric }
VisitUnaryPostInc(const UnaryOperator * E)2030b57cec5SDimitry Andric ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) {
2040b57cec5SDimitry Andric return VisitPrePostIncDec(E, true, false);
2050b57cec5SDimitry Andric }
VisitUnaryPreDec(const UnaryOperator * E)2060b57cec5SDimitry Andric ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) {
2070b57cec5SDimitry Andric return VisitPrePostIncDec(E, false, true);
2080b57cec5SDimitry Andric }
VisitUnaryPreInc(const UnaryOperator * E)2090b57cec5SDimitry Andric ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) {
2100b57cec5SDimitry Andric return VisitPrePostIncDec(E, true, true);
2110b57cec5SDimitry Andric }
VisitUnaryDeref(const Expr * E)2120b57cec5SDimitry Andric ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
213bdd1243dSDimitry Andric
214bdd1243dSDimitry Andric ComplexPairTy VisitUnaryPlus(const UnaryOperator *E,
215bdd1243dSDimitry Andric QualType PromotionType = QualType());
216bdd1243dSDimitry Andric ComplexPairTy VisitPlus(const UnaryOperator *E, QualType PromotionType);
217bdd1243dSDimitry Andric ComplexPairTy VisitUnaryMinus(const UnaryOperator *E,
218bdd1243dSDimitry Andric QualType PromotionType = QualType());
219bdd1243dSDimitry Andric ComplexPairTy VisitMinus(const UnaryOperator *E, QualType PromotionType);
2200b57cec5SDimitry Andric ComplexPairTy VisitUnaryNot (const UnaryOperator *E);
2210b57cec5SDimitry Andric // LNot,Real,Imag never return complex.
VisitUnaryExtension(const UnaryOperator * E)2220b57cec5SDimitry Andric ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) {
2230b57cec5SDimitry Andric return Visit(E->getSubExpr());
2240b57cec5SDimitry Andric }
VisitCXXDefaultArgExpr(CXXDefaultArgExpr * DAE)2250b57cec5SDimitry Andric ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
2260b57cec5SDimitry Andric CodeGenFunction::CXXDefaultArgExprScope Scope(CGF, DAE);
2270b57cec5SDimitry Andric return Visit(DAE->getExpr());
2280b57cec5SDimitry Andric }
VisitCXXDefaultInitExpr(CXXDefaultInitExpr * DIE)2290b57cec5SDimitry Andric ComplexPairTy VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
2300b57cec5SDimitry Andric CodeGenFunction::CXXDefaultInitExprScope Scope(CGF, DIE);
2310b57cec5SDimitry Andric return Visit(DIE->getExpr());
2320b57cec5SDimitry Andric }
VisitExprWithCleanups(ExprWithCleanups * E)2330b57cec5SDimitry Andric ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) {
2340b57cec5SDimitry Andric CodeGenFunction::RunCleanupsScope Scope(CGF);
2350b57cec5SDimitry Andric ComplexPairTy Vals = Visit(E->getSubExpr());
2360b57cec5SDimitry Andric // Defend against dominance problems caused by jumps out of expression
2370b57cec5SDimitry Andric // evaluation through the shared cleanup block.
2380b57cec5SDimitry Andric Scope.ForceCleanup({&Vals.first, &Vals.second});
2390b57cec5SDimitry Andric return Vals;
2400b57cec5SDimitry Andric }
VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr * E)2410b57cec5SDimitry Andric ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
2420b57cec5SDimitry Andric assert(E->getType()->isAnyComplexType() && "Expected complex type!");
2430b57cec5SDimitry Andric QualType Elem = E->getType()->castAs<ComplexType>()->getElementType();
2440b57cec5SDimitry Andric llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem));
2450b57cec5SDimitry Andric return ComplexPairTy(Null, Null);
2460b57cec5SDimitry Andric }
VisitImplicitValueInitExpr(ImplicitValueInitExpr * E)2470b57cec5SDimitry Andric ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
2480b57cec5SDimitry Andric assert(E->getType()->isAnyComplexType() && "Expected complex type!");
2490b57cec5SDimitry Andric QualType Elem = E->getType()->castAs<ComplexType>()->getElementType();
2500b57cec5SDimitry Andric llvm::Constant *Null =
2510b57cec5SDimitry Andric llvm::Constant::getNullValue(CGF.ConvertType(Elem));
2520b57cec5SDimitry Andric return ComplexPairTy(Null, Null);
2530b57cec5SDimitry Andric }
2540b57cec5SDimitry Andric
2550b57cec5SDimitry Andric struct BinOpInfo {
2560b57cec5SDimitry Andric ComplexPairTy LHS;
2570b57cec5SDimitry Andric ComplexPairTy RHS;
2580b57cec5SDimitry Andric QualType Ty; // Computation Type.
259bdd1243dSDimitry Andric FPOptions FPFeatures;
2600b57cec5SDimitry Andric };
2610b57cec5SDimitry Andric
262bdd1243dSDimitry Andric BinOpInfo EmitBinOps(const BinaryOperator *E,
263bdd1243dSDimitry Andric QualType PromotionTy = QualType());
264bdd1243dSDimitry Andric ComplexPairTy EmitPromoted(const Expr *E, QualType PromotionTy);
265bdd1243dSDimitry Andric ComplexPairTy EmitPromotedComplexOperand(const Expr *E, QualType PromotionTy);
2660b57cec5SDimitry Andric LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
2670b57cec5SDimitry Andric ComplexPairTy (ComplexExprEmitter::*Func)
2680b57cec5SDimitry Andric (const BinOpInfo &),
2690b57cec5SDimitry Andric RValue &Val);
2700b57cec5SDimitry Andric ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E,
2710b57cec5SDimitry Andric ComplexPairTy (ComplexExprEmitter::*Func)
2720b57cec5SDimitry Andric (const BinOpInfo &));
2730b57cec5SDimitry Andric
2740b57cec5SDimitry Andric ComplexPairTy EmitBinAdd(const BinOpInfo &Op);
2750b57cec5SDimitry Andric ComplexPairTy EmitBinSub(const BinOpInfo &Op);
2760b57cec5SDimitry Andric ComplexPairTy EmitBinMul(const BinOpInfo &Op);
2770b57cec5SDimitry Andric ComplexPairTy EmitBinDiv(const BinOpInfo &Op);
2785f757f3fSDimitry Andric ComplexPairTy EmitAlgebraicDiv(llvm::Value *A, llvm::Value *B, llvm::Value *C,
2795f757f3fSDimitry Andric llvm::Value *D);
2805f757f3fSDimitry Andric ComplexPairTy EmitRangeReductionDiv(llvm::Value *A, llvm::Value *B,
2815f757f3fSDimitry Andric llvm::Value *C, llvm::Value *D);
2820b57cec5SDimitry Andric
2830b57cec5SDimitry Andric ComplexPairTy EmitComplexBinOpLibCall(StringRef LibCallName,
2840b57cec5SDimitry Andric const BinOpInfo &Op);
2850b57cec5SDimitry Andric
getPromotionType(QualType Ty)286bdd1243dSDimitry Andric QualType getPromotionType(QualType Ty) {
287bdd1243dSDimitry Andric if (auto *CT = Ty->getAs<ComplexType>()) {
288bdd1243dSDimitry Andric QualType ElementType = CT->getElementType();
289bdd1243dSDimitry Andric if (ElementType.UseExcessPrecision(CGF.getContext()))
290bdd1243dSDimitry Andric return CGF.getContext().getComplexType(CGF.getContext().FloatTy);
2910b57cec5SDimitry Andric }
292bdd1243dSDimitry Andric if (Ty.UseExcessPrecision(CGF.getContext()))
293bdd1243dSDimitry Andric return CGF.getContext().FloatTy;
294bdd1243dSDimitry Andric return QualType();
2950b57cec5SDimitry Andric }
296bdd1243dSDimitry Andric
297bdd1243dSDimitry Andric #define HANDLEBINOP(OP) \
298bdd1243dSDimitry Andric ComplexPairTy VisitBin##OP(const BinaryOperator *E) { \
299bdd1243dSDimitry Andric QualType promotionTy = getPromotionType(E->getType()); \
300bdd1243dSDimitry Andric ComplexPairTy result = EmitBin##OP(EmitBinOps(E, promotionTy)); \
301bdd1243dSDimitry Andric if (!promotionTy.isNull()) \
302bdd1243dSDimitry Andric result = \
303bdd1243dSDimitry Andric CGF.EmitUnPromotedValue(result, E->getType()); \
304bdd1243dSDimitry Andric return result; \
3050b57cec5SDimitry Andric }
306bdd1243dSDimitry Andric
307bdd1243dSDimitry Andric HANDLEBINOP(Mul)
HANDLEBINOP(Div)308bdd1243dSDimitry Andric HANDLEBINOP(Div)
309bdd1243dSDimitry Andric HANDLEBINOP(Add)
310bdd1243dSDimitry Andric HANDLEBINOP(Sub)
311bdd1243dSDimitry Andric #undef HANDLEBINOP
3120b57cec5SDimitry Andric
313a7dea167SDimitry Andric ComplexPairTy VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) {
314a7dea167SDimitry Andric return Visit(E->getSemanticForm());
315a7dea167SDimitry Andric }
316a7dea167SDimitry Andric
3170b57cec5SDimitry Andric // Compound assignments.
VisitBinAddAssign(const CompoundAssignOperator * E)3180b57cec5SDimitry Andric ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) {
3190b57cec5SDimitry Andric return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd);
3200b57cec5SDimitry Andric }
VisitBinSubAssign(const CompoundAssignOperator * E)3210b57cec5SDimitry Andric ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) {
3220b57cec5SDimitry Andric return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub);
3230b57cec5SDimitry Andric }
VisitBinMulAssign(const CompoundAssignOperator * E)3240b57cec5SDimitry Andric ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) {
3250b57cec5SDimitry Andric return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul);
3260b57cec5SDimitry Andric }
VisitBinDivAssign(const CompoundAssignOperator * E)3270b57cec5SDimitry Andric ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) {
3280b57cec5SDimitry Andric return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv);
3290b57cec5SDimitry Andric }
3300b57cec5SDimitry Andric
3310b57cec5SDimitry Andric // GCC rejects rem/and/or/xor for integer complex.
3320b57cec5SDimitry Andric // Logical and/or always return int, never complex.
3330b57cec5SDimitry Andric
3340b57cec5SDimitry Andric // No comparisons produce a complex result.
3350b57cec5SDimitry Andric
3360b57cec5SDimitry Andric LValue EmitBinAssignLValue(const BinaryOperator *E,
3370b57cec5SDimitry Andric ComplexPairTy &Val);
3380b57cec5SDimitry Andric ComplexPairTy VisitBinAssign (const BinaryOperator *E);
3390b57cec5SDimitry Andric ComplexPairTy VisitBinComma (const BinaryOperator *E);
3400b57cec5SDimitry Andric
3410b57cec5SDimitry Andric
3420b57cec5SDimitry Andric ComplexPairTy
3430b57cec5SDimitry Andric VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO);
3440b57cec5SDimitry Andric ComplexPairTy VisitChooseExpr(ChooseExpr *CE);
3450b57cec5SDimitry Andric
3460b57cec5SDimitry Andric ComplexPairTy VisitInitListExpr(InitListExpr *E);
3470b57cec5SDimitry Andric
VisitCompoundLiteralExpr(CompoundLiteralExpr * E)3480b57cec5SDimitry Andric ComplexPairTy VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
3490b57cec5SDimitry Andric return EmitLoadOfLValue(E);
3500b57cec5SDimitry Andric }
3510b57cec5SDimitry Andric
3520b57cec5SDimitry Andric ComplexPairTy VisitVAArgExpr(VAArgExpr *E);
3530b57cec5SDimitry Andric
VisitAtomicExpr(AtomicExpr * E)3540b57cec5SDimitry Andric ComplexPairTy VisitAtomicExpr(AtomicExpr *E) {
3550b57cec5SDimitry Andric return CGF.EmitAtomicExpr(E).getComplexVal();
3560b57cec5SDimitry Andric }
3570b57cec5SDimitry Andric };
3580b57cec5SDimitry Andric } // end anonymous namespace.
3590b57cec5SDimitry Andric
3600b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
3610b57cec5SDimitry Andric // Utilities
3620b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
3630b57cec5SDimitry Andric
emitAddrOfRealComponent(Address addr,QualType complexType)3640b57cec5SDimitry Andric Address CodeGenFunction::emitAddrOfRealComponent(Address addr,
3650b57cec5SDimitry Andric QualType complexType) {
3660b57cec5SDimitry Andric return Builder.CreateStructGEP(addr, 0, addr.getName() + ".realp");
3670b57cec5SDimitry Andric }
3680b57cec5SDimitry Andric
emitAddrOfImagComponent(Address addr,QualType complexType)3690b57cec5SDimitry Andric Address CodeGenFunction::emitAddrOfImagComponent(Address addr,
3700b57cec5SDimitry Andric QualType complexType) {
3710b57cec5SDimitry Andric return Builder.CreateStructGEP(addr, 1, addr.getName() + ".imagp");
3720b57cec5SDimitry Andric }
3730b57cec5SDimitry Andric
3740b57cec5SDimitry Andric /// EmitLoadOfLValue - Given an RValue reference for a complex, emit code to
3750b57cec5SDimitry Andric /// load the real and imaginary pieces, returning them as Real/Imag.
EmitLoadOfLValue(LValue lvalue,SourceLocation loc)3760b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::EmitLoadOfLValue(LValue lvalue,
3770b57cec5SDimitry Andric SourceLocation loc) {
3780b57cec5SDimitry Andric assert(lvalue.isSimple() && "non-simple complex l-value?");
3790b57cec5SDimitry Andric if (lvalue.getType()->isAtomicType())
3800b57cec5SDimitry Andric return CGF.EmitAtomicLoad(lvalue, loc).getComplexVal();
3810b57cec5SDimitry Andric
382480093f4SDimitry Andric Address SrcPtr = lvalue.getAddress(CGF);
3830b57cec5SDimitry Andric bool isVolatile = lvalue.isVolatileQualified();
3840b57cec5SDimitry Andric
3850b57cec5SDimitry Andric llvm::Value *Real = nullptr, *Imag = nullptr;
3860b57cec5SDimitry Andric
3870b57cec5SDimitry Andric if (!IgnoreReal || isVolatile) {
3880b57cec5SDimitry Andric Address RealP = CGF.emitAddrOfRealComponent(SrcPtr, lvalue.getType());
3890b57cec5SDimitry Andric Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr.getName() + ".real");
3900b57cec5SDimitry Andric }
3910b57cec5SDimitry Andric
3920b57cec5SDimitry Andric if (!IgnoreImag || isVolatile) {
3930b57cec5SDimitry Andric Address ImagP = CGF.emitAddrOfImagComponent(SrcPtr, lvalue.getType());
3940b57cec5SDimitry Andric Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr.getName() + ".imag");
3950b57cec5SDimitry Andric }
3960b57cec5SDimitry Andric
3970b57cec5SDimitry Andric return ComplexPairTy(Real, Imag);
3980b57cec5SDimitry Andric }
3990b57cec5SDimitry Andric
4000b57cec5SDimitry Andric /// EmitStoreOfComplex - Store the specified real/imag parts into the
4010b57cec5SDimitry Andric /// specified value pointer.
EmitStoreOfComplex(ComplexPairTy Val,LValue lvalue,bool isInit)4020b57cec5SDimitry Andric void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, LValue lvalue,
4030b57cec5SDimitry Andric bool isInit) {
4040b57cec5SDimitry Andric if (lvalue.getType()->isAtomicType() ||
4050b57cec5SDimitry Andric (!isInit && CGF.LValueIsSuitableForInlineAtomic(lvalue)))
4060b57cec5SDimitry Andric return CGF.EmitAtomicStore(RValue::getComplex(Val), lvalue, isInit);
4070b57cec5SDimitry Andric
408480093f4SDimitry Andric Address Ptr = lvalue.getAddress(CGF);
4090b57cec5SDimitry Andric Address RealPtr = CGF.emitAddrOfRealComponent(Ptr, lvalue.getType());
4100b57cec5SDimitry Andric Address ImagPtr = CGF.emitAddrOfImagComponent(Ptr, lvalue.getType());
4110b57cec5SDimitry Andric
4120b57cec5SDimitry Andric Builder.CreateStore(Val.first, RealPtr, lvalue.isVolatileQualified());
4130b57cec5SDimitry Andric Builder.CreateStore(Val.second, ImagPtr, lvalue.isVolatileQualified());
4140b57cec5SDimitry Andric }
4150b57cec5SDimitry Andric
4160b57cec5SDimitry Andric
4170b57cec5SDimitry Andric
4180b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
4190b57cec5SDimitry Andric // Visitor Methods
4200b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
4210b57cec5SDimitry Andric
VisitExpr(Expr * E)4220b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
4230b57cec5SDimitry Andric CGF.ErrorUnsupported(E, "complex expression");
4240b57cec5SDimitry Andric llvm::Type *EltTy =
4250b57cec5SDimitry Andric CGF.ConvertType(getComplexType(E->getType())->getElementType());
4260b57cec5SDimitry Andric llvm::Value *U = llvm::UndefValue::get(EltTy);
4270b57cec5SDimitry Andric return ComplexPairTy(U, U);
4280b57cec5SDimitry Andric }
4290b57cec5SDimitry Andric
4300b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::
VisitImaginaryLiteral(const ImaginaryLiteral * IL)4310b57cec5SDimitry Andric VisitImaginaryLiteral(const ImaginaryLiteral *IL) {
4320b57cec5SDimitry Andric llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr());
4330b57cec5SDimitry Andric return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag);
4340b57cec5SDimitry Andric }
4350b57cec5SDimitry Andric
4360b57cec5SDimitry Andric
VisitCallExpr(const CallExpr * E)4370b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) {
4380b57cec5SDimitry Andric if (E->getCallReturnType(CGF.getContext())->isReferenceType())
4390b57cec5SDimitry Andric return EmitLoadOfLValue(E);
4400b57cec5SDimitry Andric
4410b57cec5SDimitry Andric return CGF.EmitCallExpr(E).getComplexVal();
4420b57cec5SDimitry Andric }
4430b57cec5SDimitry Andric
VisitStmtExpr(const StmtExpr * E)4440b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) {
4450b57cec5SDimitry Andric CodeGenFunction::StmtExprEvaluation eval(CGF);
4460b57cec5SDimitry Andric Address RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(), true);
4470b57cec5SDimitry Andric assert(RetAlloca.isValid() && "Expected complex return value");
4480b57cec5SDimitry Andric return EmitLoadOfLValue(CGF.MakeAddrLValue(RetAlloca, E->getType()),
4490b57cec5SDimitry Andric E->getExprLoc());
4500b57cec5SDimitry Andric }
4510b57cec5SDimitry Andric
4520b57cec5SDimitry Andric /// Emit a cast from complex value Val to DestType.
EmitComplexToComplexCast(ComplexPairTy Val,QualType SrcType,QualType DestType,SourceLocation Loc)4530b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val,
4540b57cec5SDimitry Andric QualType SrcType,
4550b57cec5SDimitry Andric QualType DestType,
4560b57cec5SDimitry Andric SourceLocation Loc) {
4570b57cec5SDimitry Andric // Get the src/dest element type.
4580b57cec5SDimitry Andric SrcType = SrcType->castAs<ComplexType>()->getElementType();
4590b57cec5SDimitry Andric DestType = DestType->castAs<ComplexType>()->getElementType();
4600b57cec5SDimitry Andric
4610b57cec5SDimitry Andric // C99 6.3.1.6: When a value of complex type is converted to another
4620b57cec5SDimitry Andric // complex type, both the real and imaginary parts follow the conversion
4630b57cec5SDimitry Andric // rules for the corresponding real types.
4645ffd83dbSDimitry Andric if (Val.first)
4650b57cec5SDimitry Andric Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType, Loc);
4665ffd83dbSDimitry Andric if (Val.second)
4670b57cec5SDimitry Andric Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType, Loc);
4680b57cec5SDimitry Andric return Val;
4690b57cec5SDimitry Andric }
4700b57cec5SDimitry Andric
EmitScalarToComplexCast(llvm::Value * Val,QualType SrcType,QualType DestType,SourceLocation Loc)4710b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::EmitScalarToComplexCast(llvm::Value *Val,
4720b57cec5SDimitry Andric QualType SrcType,
4730b57cec5SDimitry Andric QualType DestType,
4740b57cec5SDimitry Andric SourceLocation Loc) {
4750b57cec5SDimitry Andric // Convert the input element to the element type of the complex.
4760b57cec5SDimitry Andric DestType = DestType->castAs<ComplexType>()->getElementType();
4770b57cec5SDimitry Andric Val = CGF.EmitScalarConversion(Val, SrcType, DestType, Loc);
4780b57cec5SDimitry Andric
4790b57cec5SDimitry Andric // Return (realval, 0).
4800b57cec5SDimitry Andric return ComplexPairTy(Val, llvm::Constant::getNullValue(Val->getType()));
4810b57cec5SDimitry Andric }
4820b57cec5SDimitry Andric
EmitCast(CastKind CK,Expr * Op,QualType DestTy)4830b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op,
4840b57cec5SDimitry Andric QualType DestTy) {
4850b57cec5SDimitry Andric switch (CK) {
4860b57cec5SDimitry Andric case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!");
4870b57cec5SDimitry Andric
4880b57cec5SDimitry Andric // Atomic to non-atomic casts may be more than a no-op for some platforms and
4890b57cec5SDimitry Andric // for some types.
4900b57cec5SDimitry Andric case CK_AtomicToNonAtomic:
4910b57cec5SDimitry Andric case CK_NonAtomicToAtomic:
4920b57cec5SDimitry Andric case CK_NoOp:
4930b57cec5SDimitry Andric case CK_LValueToRValue:
4940b57cec5SDimitry Andric case CK_UserDefinedConversion:
4950b57cec5SDimitry Andric return Visit(Op);
4960b57cec5SDimitry Andric
4970b57cec5SDimitry Andric case CK_LValueBitCast: {
4980b57cec5SDimitry Andric LValue origLV = CGF.EmitLValue(Op);
49906c3fb27SDimitry Andric Address V = origLV.getAddress(CGF).withElementType(CGF.ConvertType(DestTy));
5000b57cec5SDimitry Andric return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy), Op->getExprLoc());
5010b57cec5SDimitry Andric }
5020b57cec5SDimitry Andric
5030b57cec5SDimitry Andric case CK_LValueToRValueBitCast: {
5040b57cec5SDimitry Andric LValue SourceLVal = CGF.EmitLValue(Op);
50506c3fb27SDimitry Andric Address Addr = SourceLVal.getAddress(CGF).withElementType(
5060b57cec5SDimitry Andric CGF.ConvertTypeForMem(DestTy));
5070b57cec5SDimitry Andric LValue DestLV = CGF.MakeAddrLValue(Addr, DestTy);
5080b57cec5SDimitry Andric DestLV.setTBAAInfo(TBAAAccessInfo::getMayAliasInfo());
5090b57cec5SDimitry Andric return EmitLoadOfLValue(DestLV, Op->getExprLoc());
5100b57cec5SDimitry Andric }
5110b57cec5SDimitry Andric
5120b57cec5SDimitry Andric case CK_BitCast:
5130b57cec5SDimitry Andric case CK_BaseToDerived:
5140b57cec5SDimitry Andric case CK_DerivedToBase:
5150b57cec5SDimitry Andric case CK_UncheckedDerivedToBase:
5160b57cec5SDimitry Andric case CK_Dynamic:
5170b57cec5SDimitry Andric case CK_ToUnion:
5180b57cec5SDimitry Andric case CK_ArrayToPointerDecay:
5190b57cec5SDimitry Andric case CK_FunctionToPointerDecay:
5200b57cec5SDimitry Andric case CK_NullToPointer:
5210b57cec5SDimitry Andric case CK_NullToMemberPointer:
5220b57cec5SDimitry Andric case CK_BaseToDerivedMemberPointer:
5230b57cec5SDimitry Andric case CK_DerivedToBaseMemberPointer:
5240b57cec5SDimitry Andric case CK_MemberPointerToBoolean:
5250b57cec5SDimitry Andric case CK_ReinterpretMemberPointer:
5260b57cec5SDimitry Andric case CK_ConstructorConversion:
5270b57cec5SDimitry Andric case CK_IntegralToPointer:
5280b57cec5SDimitry Andric case CK_PointerToIntegral:
5290b57cec5SDimitry Andric case CK_PointerToBoolean:
5300b57cec5SDimitry Andric case CK_ToVoid:
5310b57cec5SDimitry Andric case CK_VectorSplat:
5320b57cec5SDimitry Andric case CK_IntegralCast:
5330b57cec5SDimitry Andric case CK_BooleanToSignedIntegral:
5340b57cec5SDimitry Andric case CK_IntegralToBoolean:
5350b57cec5SDimitry Andric case CK_IntegralToFloating:
5360b57cec5SDimitry Andric case CK_FloatingToIntegral:
5370b57cec5SDimitry Andric case CK_FloatingToBoolean:
5380b57cec5SDimitry Andric case CK_FloatingCast:
5390b57cec5SDimitry Andric case CK_CPointerToObjCPointerCast:
5400b57cec5SDimitry Andric case CK_BlockPointerToObjCPointerCast:
5410b57cec5SDimitry Andric case CK_AnyPointerToBlockPointerCast:
5420b57cec5SDimitry Andric case CK_ObjCObjectLValueCast:
5430b57cec5SDimitry Andric case CK_FloatingComplexToReal:
5440b57cec5SDimitry Andric case CK_FloatingComplexToBoolean:
5450b57cec5SDimitry Andric case CK_IntegralComplexToReal:
5460b57cec5SDimitry Andric case CK_IntegralComplexToBoolean:
5470b57cec5SDimitry Andric case CK_ARCProduceObject:
5480b57cec5SDimitry Andric case CK_ARCConsumeObject:
5490b57cec5SDimitry Andric case CK_ARCReclaimReturnedObject:
5500b57cec5SDimitry Andric case CK_ARCExtendBlockObject:
5510b57cec5SDimitry Andric case CK_CopyAndAutoreleaseBlockObject:
5520b57cec5SDimitry Andric case CK_BuiltinFnToFnPtr:
5530b57cec5SDimitry Andric case CK_ZeroToOCLOpaqueType:
5540b57cec5SDimitry Andric case CK_AddressSpaceConversion:
5550b57cec5SDimitry Andric case CK_IntToOCLSampler:
556e8d8bef9SDimitry Andric case CK_FloatingToFixedPoint:
557e8d8bef9SDimitry Andric case CK_FixedPointToFloating:
5580b57cec5SDimitry Andric case CK_FixedPointCast:
5590b57cec5SDimitry Andric case CK_FixedPointToBoolean:
5600b57cec5SDimitry Andric case CK_FixedPointToIntegral:
5610b57cec5SDimitry Andric case CK_IntegralToFixedPoint:
562fe6060f1SDimitry Andric case CK_MatrixCast:
5630b57cec5SDimitry Andric llvm_unreachable("invalid cast kind for complex value");
5640b57cec5SDimitry Andric
5650b57cec5SDimitry Andric case CK_FloatingRealToComplex:
566e8d8bef9SDimitry Andric case CK_IntegralRealToComplex: {
567e8d8bef9SDimitry Andric CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op);
5680b57cec5SDimitry Andric return EmitScalarToComplexCast(CGF.EmitScalarExpr(Op), Op->getType(),
5690b57cec5SDimitry Andric DestTy, Op->getExprLoc());
570e8d8bef9SDimitry Andric }
5710b57cec5SDimitry Andric
5720b57cec5SDimitry Andric case CK_FloatingComplexCast:
5730b57cec5SDimitry Andric case CK_FloatingComplexToIntegralComplex:
5740b57cec5SDimitry Andric case CK_IntegralComplexCast:
575e8d8bef9SDimitry Andric case CK_IntegralComplexToFloatingComplex: {
576e8d8bef9SDimitry Andric CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op);
5770b57cec5SDimitry Andric return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy,
5780b57cec5SDimitry Andric Op->getExprLoc());
5790b57cec5SDimitry Andric }
580e8d8bef9SDimitry Andric }
5810b57cec5SDimitry Andric
5820b57cec5SDimitry Andric llvm_unreachable("unknown cast resulting in complex value");
5830b57cec5SDimitry Andric }
5840b57cec5SDimitry Andric
VisitUnaryPlus(const UnaryOperator * E,QualType PromotionType)585bdd1243dSDimitry Andric ComplexPairTy ComplexExprEmitter::VisitUnaryPlus(const UnaryOperator *E,
586bdd1243dSDimitry Andric QualType PromotionType) {
587bdd1243dSDimitry Andric QualType promotionTy = PromotionType.isNull()
588bdd1243dSDimitry Andric ? getPromotionType(E->getSubExpr()->getType())
589bdd1243dSDimitry Andric : PromotionType;
590bdd1243dSDimitry Andric ComplexPairTy result = VisitPlus(E, promotionTy);
591bdd1243dSDimitry Andric if (!promotionTy.isNull())
592bdd1243dSDimitry Andric return CGF.EmitUnPromotedValue(result, E->getSubExpr()->getType());
593bdd1243dSDimitry Andric return result;
594bdd1243dSDimitry Andric }
595bdd1243dSDimitry Andric
VisitPlus(const UnaryOperator * E,QualType PromotionType)596bdd1243dSDimitry Andric ComplexPairTy ComplexExprEmitter::VisitPlus(const UnaryOperator *E,
597bdd1243dSDimitry Andric QualType PromotionType) {
5980b57cec5SDimitry Andric TestAndClearIgnoreReal();
5990b57cec5SDimitry Andric TestAndClearIgnoreImag();
600bdd1243dSDimitry Andric if (!PromotionType.isNull())
601bdd1243dSDimitry Andric return CGF.EmitPromotedComplexExpr(E->getSubExpr(), PromotionType);
602bdd1243dSDimitry Andric return Visit(E->getSubExpr());
603bdd1243dSDimitry Andric }
604bdd1243dSDimitry Andric
VisitUnaryMinus(const UnaryOperator * E,QualType PromotionType)605bdd1243dSDimitry Andric ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E,
606bdd1243dSDimitry Andric QualType PromotionType) {
607bdd1243dSDimitry Andric QualType promotionTy = PromotionType.isNull()
608bdd1243dSDimitry Andric ? getPromotionType(E->getSubExpr()->getType())
609bdd1243dSDimitry Andric : PromotionType;
610bdd1243dSDimitry Andric ComplexPairTy result = VisitMinus(E, promotionTy);
611bdd1243dSDimitry Andric if (!promotionTy.isNull())
612bdd1243dSDimitry Andric return CGF.EmitUnPromotedValue(result, E->getSubExpr()->getType());
613bdd1243dSDimitry Andric return result;
614bdd1243dSDimitry Andric }
VisitMinus(const UnaryOperator * E,QualType PromotionType)615bdd1243dSDimitry Andric ComplexPairTy ComplexExprEmitter::VisitMinus(const UnaryOperator *E,
616bdd1243dSDimitry Andric QualType PromotionType) {
617bdd1243dSDimitry Andric TestAndClearIgnoreReal();
618bdd1243dSDimitry Andric TestAndClearIgnoreImag();
619bdd1243dSDimitry Andric ComplexPairTy Op;
620bdd1243dSDimitry Andric if (!PromotionType.isNull())
621bdd1243dSDimitry Andric Op = CGF.EmitPromotedComplexExpr(E->getSubExpr(), PromotionType);
622bdd1243dSDimitry Andric else
623bdd1243dSDimitry Andric Op = Visit(E->getSubExpr());
6240b57cec5SDimitry Andric
6250b57cec5SDimitry Andric llvm::Value *ResR, *ResI;
6260b57cec5SDimitry Andric if (Op.first->getType()->isFloatingPointTy()) {
6270b57cec5SDimitry Andric ResR = Builder.CreateFNeg(Op.first, "neg.r");
6280b57cec5SDimitry Andric ResI = Builder.CreateFNeg(Op.second, "neg.i");
6290b57cec5SDimitry Andric } else {
6300b57cec5SDimitry Andric ResR = Builder.CreateNeg(Op.first, "neg.r");
6310b57cec5SDimitry Andric ResI = Builder.CreateNeg(Op.second, "neg.i");
6320b57cec5SDimitry Andric }
6330b57cec5SDimitry Andric return ComplexPairTy(ResR, ResI);
6340b57cec5SDimitry Andric }
6350b57cec5SDimitry Andric
VisitUnaryNot(const UnaryOperator * E)6360b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
6370b57cec5SDimitry Andric TestAndClearIgnoreReal();
6380b57cec5SDimitry Andric TestAndClearIgnoreImag();
6390b57cec5SDimitry Andric // ~(a+ib) = a + i*-b
6400b57cec5SDimitry Andric ComplexPairTy Op = Visit(E->getSubExpr());
6410b57cec5SDimitry Andric llvm::Value *ResI;
6420b57cec5SDimitry Andric if (Op.second->getType()->isFloatingPointTy())
6430b57cec5SDimitry Andric ResI = Builder.CreateFNeg(Op.second, "conj.i");
6440b57cec5SDimitry Andric else
6450b57cec5SDimitry Andric ResI = Builder.CreateNeg(Op.second, "conj.i");
6460b57cec5SDimitry Andric
6470b57cec5SDimitry Andric return ComplexPairTy(Op.first, ResI);
6480b57cec5SDimitry Andric }
6490b57cec5SDimitry Andric
EmitBinAdd(const BinOpInfo & Op)6500b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) {
6510b57cec5SDimitry Andric llvm::Value *ResR, *ResI;
6520b57cec5SDimitry Andric
6530b57cec5SDimitry Andric if (Op.LHS.first->getType()->isFloatingPointTy()) {
654bdd1243dSDimitry Andric CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op.FPFeatures);
6550b57cec5SDimitry Andric ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r");
6560b57cec5SDimitry Andric if (Op.LHS.second && Op.RHS.second)
6570b57cec5SDimitry Andric ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i");
6580b57cec5SDimitry Andric else
6590b57cec5SDimitry Andric ResI = Op.LHS.second ? Op.LHS.second : Op.RHS.second;
6600b57cec5SDimitry Andric assert(ResI && "Only one operand may be real!");
6610b57cec5SDimitry Andric } else {
6620b57cec5SDimitry Andric ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r");
6630b57cec5SDimitry Andric assert(Op.LHS.second && Op.RHS.second &&
6640b57cec5SDimitry Andric "Both operands of integer complex operators must be complex!");
6650b57cec5SDimitry Andric ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i");
6660b57cec5SDimitry Andric }
6670b57cec5SDimitry Andric return ComplexPairTy(ResR, ResI);
6680b57cec5SDimitry Andric }
6690b57cec5SDimitry Andric
EmitBinSub(const BinOpInfo & Op)6700b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) {
6710b57cec5SDimitry Andric llvm::Value *ResR, *ResI;
6720b57cec5SDimitry Andric if (Op.LHS.first->getType()->isFloatingPointTy()) {
673bdd1243dSDimitry Andric CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op.FPFeatures);
6740b57cec5SDimitry Andric ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r");
6750b57cec5SDimitry Andric if (Op.LHS.second && Op.RHS.second)
6760b57cec5SDimitry Andric ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i");
6770b57cec5SDimitry Andric else
6780b57cec5SDimitry Andric ResI = Op.LHS.second ? Op.LHS.second
6790b57cec5SDimitry Andric : Builder.CreateFNeg(Op.RHS.second, "sub.i");
6800b57cec5SDimitry Andric assert(ResI && "Only one operand may be real!");
6810b57cec5SDimitry Andric } else {
6820b57cec5SDimitry Andric ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r");
6830b57cec5SDimitry Andric assert(Op.LHS.second && Op.RHS.second &&
6840b57cec5SDimitry Andric "Both operands of integer complex operators must be complex!");
6850b57cec5SDimitry Andric ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i");
6860b57cec5SDimitry Andric }
6870b57cec5SDimitry Andric return ComplexPairTy(ResR, ResI);
6880b57cec5SDimitry Andric }
6890b57cec5SDimitry Andric
6900b57cec5SDimitry Andric /// Emit a libcall for a binary operation on complex types.
EmitComplexBinOpLibCall(StringRef LibCallName,const BinOpInfo & Op)6910b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::EmitComplexBinOpLibCall(StringRef LibCallName,
6920b57cec5SDimitry Andric const BinOpInfo &Op) {
6930b57cec5SDimitry Andric CallArgList Args;
6940b57cec5SDimitry Andric Args.add(RValue::get(Op.LHS.first),
6950b57cec5SDimitry Andric Op.Ty->castAs<ComplexType>()->getElementType());
6960b57cec5SDimitry Andric Args.add(RValue::get(Op.LHS.second),
6970b57cec5SDimitry Andric Op.Ty->castAs<ComplexType>()->getElementType());
6980b57cec5SDimitry Andric Args.add(RValue::get(Op.RHS.first),
6990b57cec5SDimitry Andric Op.Ty->castAs<ComplexType>()->getElementType());
7000b57cec5SDimitry Andric Args.add(RValue::get(Op.RHS.second),
7010b57cec5SDimitry Andric Op.Ty->castAs<ComplexType>()->getElementType());
7020b57cec5SDimitry Andric
7030b57cec5SDimitry Andric // We *must* use the full CG function call building logic here because the
7040b57cec5SDimitry Andric // complex type has special ABI handling. We also should not forget about
7050b57cec5SDimitry Andric // special calling convention which may be used for compiler builtins.
7060b57cec5SDimitry Andric
7070b57cec5SDimitry Andric // We create a function qualified type to state that this call does not have
7080b57cec5SDimitry Andric // any exceptions.
7090b57cec5SDimitry Andric FunctionProtoType::ExtProtoInfo EPI;
7100b57cec5SDimitry Andric EPI = EPI.withExceptionSpec(
7110b57cec5SDimitry Andric FunctionProtoType::ExceptionSpecInfo(EST_BasicNoexcept));
7120b57cec5SDimitry Andric SmallVector<QualType, 4> ArgsQTys(
7130b57cec5SDimitry Andric 4, Op.Ty->castAs<ComplexType>()->getElementType());
7140b57cec5SDimitry Andric QualType FQTy = CGF.getContext().getFunctionType(Op.Ty, ArgsQTys, EPI);
7150b57cec5SDimitry Andric const CGFunctionInfo &FuncInfo = CGF.CGM.getTypes().arrangeFreeFunctionCall(
7160b57cec5SDimitry Andric Args, cast<FunctionType>(FQTy.getTypePtr()), false);
7170b57cec5SDimitry Andric
7180b57cec5SDimitry Andric llvm::FunctionType *FTy = CGF.CGM.getTypes().GetFunctionType(FuncInfo);
7190b57cec5SDimitry Andric llvm::FunctionCallee Func = CGF.CGM.CreateRuntimeFunction(
7200b57cec5SDimitry Andric FTy, LibCallName, llvm::AttributeList(), true);
7210b57cec5SDimitry Andric CGCallee Callee = CGCallee::forDirect(Func, FQTy->getAs<FunctionProtoType>());
7220b57cec5SDimitry Andric
7230b57cec5SDimitry Andric llvm::CallBase *Call;
7240b57cec5SDimitry Andric RValue Res = CGF.EmitCall(FuncInfo, Callee, ReturnValueSlot(), Args, &Call);
7250b57cec5SDimitry Andric Call->setCallingConv(CGF.CGM.getRuntimeCC());
7260b57cec5SDimitry Andric return Res.getComplexVal();
7270b57cec5SDimitry Andric }
7280b57cec5SDimitry Andric
7290b57cec5SDimitry Andric /// Lookup the libcall name for a given floating point type complex
7300b57cec5SDimitry Andric /// multiply.
getComplexMultiplyLibCallName(llvm::Type * Ty)7310b57cec5SDimitry Andric static StringRef getComplexMultiplyLibCallName(llvm::Type *Ty) {
7320b57cec5SDimitry Andric switch (Ty->getTypeID()) {
7330b57cec5SDimitry Andric default:
7340b57cec5SDimitry Andric llvm_unreachable("Unsupported floating point type!");
7350b57cec5SDimitry Andric case llvm::Type::HalfTyID:
7360b57cec5SDimitry Andric return "__mulhc3";
7370b57cec5SDimitry Andric case llvm::Type::FloatTyID:
7380b57cec5SDimitry Andric return "__mulsc3";
7390b57cec5SDimitry Andric case llvm::Type::DoubleTyID:
7400b57cec5SDimitry Andric return "__muldc3";
7410b57cec5SDimitry Andric case llvm::Type::PPC_FP128TyID:
7420b57cec5SDimitry Andric return "__multc3";
7430b57cec5SDimitry Andric case llvm::Type::X86_FP80TyID:
7440b57cec5SDimitry Andric return "__mulxc3";
7450b57cec5SDimitry Andric case llvm::Type::FP128TyID:
7460b57cec5SDimitry Andric return "__multc3";
7470b57cec5SDimitry Andric }
7480b57cec5SDimitry Andric }
7490b57cec5SDimitry Andric
7500b57cec5SDimitry Andric // See C11 Annex G.5.1 for the semantics of multiplicative operators on complex
7510b57cec5SDimitry Andric // typed values.
EmitBinMul(const BinOpInfo & Op)7520b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) {
7530b57cec5SDimitry Andric using llvm::Value;
7540b57cec5SDimitry Andric Value *ResR, *ResI;
7550b57cec5SDimitry Andric llvm::MDBuilder MDHelper(CGF.getLLVMContext());
7560b57cec5SDimitry Andric
7570b57cec5SDimitry Andric if (Op.LHS.first->getType()->isFloatingPointTy()) {
7580b57cec5SDimitry Andric // The general formulation is:
7590b57cec5SDimitry Andric // (a + ib) * (c + id) = (a * c - b * d) + i(a * d + b * c)
7600b57cec5SDimitry Andric //
7610b57cec5SDimitry Andric // But we can fold away components which would be zero due to a real
7620b57cec5SDimitry Andric // operand according to C11 Annex G.5.1p2.
7630b57cec5SDimitry Andric // FIXME: C11 also provides for imaginary types which would allow folding
7640b57cec5SDimitry Andric // still more of this within the type system.
7650b57cec5SDimitry Andric
766bdd1243dSDimitry Andric CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op.FPFeatures);
7670b57cec5SDimitry Andric if (Op.LHS.second && Op.RHS.second) {
7680b57cec5SDimitry Andric // If both operands are complex, emit the core math directly, and then
7690b57cec5SDimitry Andric // test for NaNs. If we find NaNs in the result, we delegate to a libcall
7700b57cec5SDimitry Andric // to carefully re-compute the correct infinity representation if
7710b57cec5SDimitry Andric // possible. The expectation is that the presence of NaNs here is
7720b57cec5SDimitry Andric // *extremely* rare, and so the cost of the libcall is almost irrelevant.
7730b57cec5SDimitry Andric // This is good, because the libcall re-computes the core multiplication
7740b57cec5SDimitry Andric // exactly the same as we do here and re-tests for NaNs in order to be
7750b57cec5SDimitry Andric // a generic complex*complex libcall.
7760b57cec5SDimitry Andric
7770b57cec5SDimitry Andric // First compute the four products.
7780b57cec5SDimitry Andric Value *AC = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul_ac");
7790b57cec5SDimitry Andric Value *BD = Builder.CreateFMul(Op.LHS.second, Op.RHS.second, "mul_bd");
7800b57cec5SDimitry Andric Value *AD = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul_ad");
7810b57cec5SDimitry Andric Value *BC = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul_bc");
7820b57cec5SDimitry Andric
7830b57cec5SDimitry Andric // The real part is the difference of the first two, the imaginary part is
7840b57cec5SDimitry Andric // the sum of the second.
7850b57cec5SDimitry Andric ResR = Builder.CreateFSub(AC, BD, "mul_r");
7860b57cec5SDimitry Andric ResI = Builder.CreateFAdd(AD, BC, "mul_i");
7870b57cec5SDimitry Andric
7885f757f3fSDimitry Andric if (Op.FPFeatures.getComplexRange() == LangOptions::CX_Limited ||
7895f757f3fSDimitry Andric Op.FPFeatures.getComplexRange() == LangOptions::CX_Fortran)
7905f757f3fSDimitry Andric return ComplexPairTy(ResR, ResI);
7915f757f3fSDimitry Andric
7920b57cec5SDimitry Andric // Emit the test for the real part becoming NaN and create a branch to
7930b57cec5SDimitry Andric // handle it. We test for NaN by comparing the number to itself.
7940b57cec5SDimitry Andric Value *IsRNaN = Builder.CreateFCmpUNO(ResR, ResR, "isnan_cmp");
7950b57cec5SDimitry Andric llvm::BasicBlock *ContBB = CGF.createBasicBlock("complex_mul_cont");
7960b57cec5SDimitry Andric llvm::BasicBlock *INaNBB = CGF.createBasicBlock("complex_mul_imag_nan");
7970b57cec5SDimitry Andric llvm::Instruction *Branch = Builder.CreateCondBr(IsRNaN, INaNBB, ContBB);
7980b57cec5SDimitry Andric llvm::BasicBlock *OrigBB = Branch->getParent();
7990b57cec5SDimitry Andric
8000b57cec5SDimitry Andric // Give hint that we very much don't expect to see NaNs.
8010b57cec5SDimitry Andric // Value chosen to match UR_NONTAKEN_WEIGHT, see BranchProbabilityInfo.cpp
8020b57cec5SDimitry Andric llvm::MDNode *BrWeight = MDHelper.createBranchWeights(1, (1U << 20) - 1);
8030b57cec5SDimitry Andric Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight);
8040b57cec5SDimitry Andric
8050b57cec5SDimitry Andric // Now test the imaginary part and create its branch.
8060b57cec5SDimitry Andric CGF.EmitBlock(INaNBB);
8070b57cec5SDimitry Andric Value *IsINaN = Builder.CreateFCmpUNO(ResI, ResI, "isnan_cmp");
8080b57cec5SDimitry Andric llvm::BasicBlock *LibCallBB = CGF.createBasicBlock("complex_mul_libcall");
8090b57cec5SDimitry Andric Branch = Builder.CreateCondBr(IsINaN, LibCallBB, ContBB);
8100b57cec5SDimitry Andric Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight);
8110b57cec5SDimitry Andric
8120b57cec5SDimitry Andric // Now emit the libcall on this slowest of the slow paths.
8130b57cec5SDimitry Andric CGF.EmitBlock(LibCallBB);
8140b57cec5SDimitry Andric Value *LibCallR, *LibCallI;
8150b57cec5SDimitry Andric std::tie(LibCallR, LibCallI) = EmitComplexBinOpLibCall(
8160b57cec5SDimitry Andric getComplexMultiplyLibCallName(Op.LHS.first->getType()), Op);
8170b57cec5SDimitry Andric Builder.CreateBr(ContBB);
8180b57cec5SDimitry Andric
8190b57cec5SDimitry Andric // Finally continue execution by phi-ing together the different
8200b57cec5SDimitry Andric // computation paths.
8210b57cec5SDimitry Andric CGF.EmitBlock(ContBB);
8220b57cec5SDimitry Andric llvm::PHINode *RealPHI = Builder.CreatePHI(ResR->getType(), 3, "real_mul_phi");
8230b57cec5SDimitry Andric RealPHI->addIncoming(ResR, OrigBB);
8240b57cec5SDimitry Andric RealPHI->addIncoming(ResR, INaNBB);
8250b57cec5SDimitry Andric RealPHI->addIncoming(LibCallR, LibCallBB);
8260b57cec5SDimitry Andric llvm::PHINode *ImagPHI = Builder.CreatePHI(ResI->getType(), 3, "imag_mul_phi");
8270b57cec5SDimitry Andric ImagPHI->addIncoming(ResI, OrigBB);
8280b57cec5SDimitry Andric ImagPHI->addIncoming(ResI, INaNBB);
8290b57cec5SDimitry Andric ImagPHI->addIncoming(LibCallI, LibCallBB);
8300b57cec5SDimitry Andric return ComplexPairTy(RealPHI, ImagPHI);
8310b57cec5SDimitry Andric }
8320b57cec5SDimitry Andric assert((Op.LHS.second || Op.RHS.second) &&
8330b57cec5SDimitry Andric "At least one operand must be complex!");
8340b57cec5SDimitry Andric
8350b57cec5SDimitry Andric // If either of the operands is a real rather than a complex, the
8360b57cec5SDimitry Andric // imaginary component is ignored when computing the real component of the
8370b57cec5SDimitry Andric // result.
8380b57cec5SDimitry Andric ResR = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl");
8390b57cec5SDimitry Andric
8400b57cec5SDimitry Andric ResI = Op.LHS.second
8410b57cec5SDimitry Andric ? Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il")
8420b57cec5SDimitry Andric : Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir");
8430b57cec5SDimitry Andric } else {
8440b57cec5SDimitry Andric assert(Op.LHS.second && Op.RHS.second &&
8450b57cec5SDimitry Andric "Both operands of integer complex operators must be complex!");
8460b57cec5SDimitry Andric Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl");
8470b57cec5SDimitry Andric Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second, "mul.rr");
8480b57cec5SDimitry Andric ResR = Builder.CreateSub(ResRl, ResRr, "mul.r");
8490b57cec5SDimitry Andric
8500b57cec5SDimitry Andric Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il");
8510b57cec5SDimitry Andric Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir");
8520b57cec5SDimitry Andric ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i");
8530b57cec5SDimitry Andric }
8540b57cec5SDimitry Andric return ComplexPairTy(ResR, ResI);
8550b57cec5SDimitry Andric }
8560b57cec5SDimitry Andric
EmitAlgebraicDiv(llvm::Value * LHSr,llvm::Value * LHSi,llvm::Value * RHSr,llvm::Value * RHSi)8575f757f3fSDimitry Andric ComplexPairTy ComplexExprEmitter::EmitAlgebraicDiv(llvm::Value *LHSr,
8585f757f3fSDimitry Andric llvm::Value *LHSi,
8595f757f3fSDimitry Andric llvm::Value *RHSr,
8605f757f3fSDimitry Andric llvm::Value *RHSi) {
8615f757f3fSDimitry Andric // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
8625f757f3fSDimitry Andric llvm::Value *DSTr, *DSTi;
8635f757f3fSDimitry Andric
8645f757f3fSDimitry Andric llvm::Value *AC = Builder.CreateFMul(LHSr, RHSr); // a*c
8655f757f3fSDimitry Andric llvm::Value *BD = Builder.CreateFMul(LHSi, RHSi); // b*d
8665f757f3fSDimitry Andric llvm::Value *ACpBD = Builder.CreateFAdd(AC, BD); // ac+bd
8675f757f3fSDimitry Andric
8685f757f3fSDimitry Andric llvm::Value *CC = Builder.CreateFMul(RHSr, RHSr); // c*c
8695f757f3fSDimitry Andric llvm::Value *DD = Builder.CreateFMul(RHSi, RHSi); // d*d
8705f757f3fSDimitry Andric llvm::Value *CCpDD = Builder.CreateFAdd(CC, DD); // cc+dd
8715f757f3fSDimitry Andric
8725f757f3fSDimitry Andric llvm::Value *BC = Builder.CreateFMul(LHSi, RHSr); // b*c
8735f757f3fSDimitry Andric llvm::Value *AD = Builder.CreateFMul(LHSr, RHSi); // a*d
8745f757f3fSDimitry Andric llvm::Value *BCmAD = Builder.CreateFSub(BC, AD); // bc-ad
8755f757f3fSDimitry Andric
8765f757f3fSDimitry Andric DSTr = Builder.CreateFDiv(ACpBD, CCpDD);
8775f757f3fSDimitry Andric DSTi = Builder.CreateFDiv(BCmAD, CCpDD);
8785f757f3fSDimitry Andric return ComplexPairTy(DSTr, DSTi);
8795f757f3fSDimitry Andric }
8805f757f3fSDimitry Andric
8815f757f3fSDimitry Andric // EmitFAbs - Emit a call to @llvm.fabs.
EmitllvmFAbs(CodeGenFunction & CGF,llvm::Value * Value)8825f757f3fSDimitry Andric static llvm::Value *EmitllvmFAbs(CodeGenFunction &CGF, llvm::Value *Value) {
8835f757f3fSDimitry Andric llvm::Function *Func =
8845f757f3fSDimitry Andric CGF.CGM.getIntrinsic(llvm::Intrinsic::fabs, Value->getType());
8855f757f3fSDimitry Andric llvm::Value *Call = CGF.Builder.CreateCall(Func, Value);
8865f757f3fSDimitry Andric return Call;
8875f757f3fSDimitry Andric }
8885f757f3fSDimitry Andric
8895f757f3fSDimitry Andric // EmitRangeReductionDiv - Implements Smith's algorithm for complex division.
8905f757f3fSDimitry Andric // SMITH, R. L. Algorithm 116: Complex division. Commun. ACM 5, 8 (1962).
EmitRangeReductionDiv(llvm::Value * LHSr,llvm::Value * LHSi,llvm::Value * RHSr,llvm::Value * RHSi)8915f757f3fSDimitry Andric ComplexPairTy ComplexExprEmitter::EmitRangeReductionDiv(llvm::Value *LHSr,
8925f757f3fSDimitry Andric llvm::Value *LHSi,
8935f757f3fSDimitry Andric llvm::Value *RHSr,
8945f757f3fSDimitry Andric llvm::Value *RHSi) {
8957a6dacacSDimitry Andric // FIXME: This could eventually be replaced by an LLVM intrinsic to
8967a6dacacSDimitry Andric // avoid this long IR sequence.
8977a6dacacSDimitry Andric
8985f757f3fSDimitry Andric // (a + ib) / (c + id) = (e + if)
8995f757f3fSDimitry Andric llvm::Value *FAbsRHSr = EmitllvmFAbs(CGF, RHSr); // |c|
9005f757f3fSDimitry Andric llvm::Value *FAbsRHSi = EmitllvmFAbs(CGF, RHSi); // |d|
9015f757f3fSDimitry Andric // |c| >= |d|
9025f757f3fSDimitry Andric llvm::Value *IsR = Builder.CreateFCmpUGT(FAbsRHSr, FAbsRHSi, "abs_cmp");
9035f757f3fSDimitry Andric
9045f757f3fSDimitry Andric llvm::BasicBlock *TrueBB =
9055f757f3fSDimitry Andric CGF.createBasicBlock("abs_rhsr_greater_or_equal_abs_rhsi");
9065f757f3fSDimitry Andric llvm::BasicBlock *FalseBB =
9075f757f3fSDimitry Andric CGF.createBasicBlock("abs_rhsr_less_than_abs_rhsi");
9085f757f3fSDimitry Andric llvm::BasicBlock *ContBB = CGF.createBasicBlock("complex_div");
9095f757f3fSDimitry Andric Builder.CreateCondBr(IsR, TrueBB, FalseBB);
9105f757f3fSDimitry Andric
9115f757f3fSDimitry Andric CGF.EmitBlock(TrueBB);
9125f757f3fSDimitry Andric // abs(c) >= abs(d)
9135f757f3fSDimitry Andric // r = d/c
9145f757f3fSDimitry Andric // tmp = c + rd
9155f757f3fSDimitry Andric // e = (a + br)/tmp
9165f757f3fSDimitry Andric // f = (b - ar)/tmp
9175f757f3fSDimitry Andric llvm::Value *DdC = Builder.CreateFDiv(RHSi, RHSr); // r=d/c
9185f757f3fSDimitry Andric
9195f757f3fSDimitry Andric llvm::Value *RD = Builder.CreateFMul(DdC, RHSi); // rd
9205f757f3fSDimitry Andric llvm::Value *CpRD = Builder.CreateFAdd(RHSr, RD); // tmp=c+rd
9215f757f3fSDimitry Andric
9225f757f3fSDimitry Andric llvm::Value *T3 = Builder.CreateFMul(LHSi, DdC); // br
9235f757f3fSDimitry Andric llvm::Value *T4 = Builder.CreateFAdd(LHSr, T3); // a+br
9245f757f3fSDimitry Andric llvm::Value *DSTTr = Builder.CreateFDiv(T4, CpRD); // (a+br)/tmp
9255f757f3fSDimitry Andric
9265f757f3fSDimitry Andric llvm::Value *T5 = Builder.CreateFMul(LHSr, DdC); // ar
9275f757f3fSDimitry Andric llvm::Value *T6 = Builder.CreateFSub(LHSi, T5); // b-ar
9285f757f3fSDimitry Andric llvm::Value *DSTTi = Builder.CreateFDiv(T6, CpRD); // (b-ar)/tmp
9295f757f3fSDimitry Andric Builder.CreateBr(ContBB);
9305f757f3fSDimitry Andric
9315f757f3fSDimitry Andric CGF.EmitBlock(FalseBB);
9325f757f3fSDimitry Andric // abs(c) < abs(d)
9335f757f3fSDimitry Andric // r = c/d
9345f757f3fSDimitry Andric // tmp = d + rc
9355f757f3fSDimitry Andric // e = (ar + b)/tmp
9365f757f3fSDimitry Andric // f = (br - a)/tmp
9375f757f3fSDimitry Andric llvm::Value *CdD = Builder.CreateFDiv(RHSr, RHSi); // r=c/d
9385f757f3fSDimitry Andric
9395f757f3fSDimitry Andric llvm::Value *RC = Builder.CreateFMul(CdD, RHSr); // rc
9405f757f3fSDimitry Andric llvm::Value *DpRC = Builder.CreateFAdd(RHSi, RC); // tmp=d+rc
9415f757f3fSDimitry Andric
9427a6dacacSDimitry Andric llvm::Value *T7 = Builder.CreateFMul(LHSr, CdD); // ar
9435f757f3fSDimitry Andric llvm::Value *T8 = Builder.CreateFAdd(T7, LHSi); // ar+b
9445f757f3fSDimitry Andric llvm::Value *DSTFr = Builder.CreateFDiv(T8, DpRC); // (ar+b)/tmp
9455f757f3fSDimitry Andric
9465f757f3fSDimitry Andric llvm::Value *T9 = Builder.CreateFMul(LHSi, CdD); // br
9475f757f3fSDimitry Andric llvm::Value *T10 = Builder.CreateFSub(T9, LHSr); // br-a
9485f757f3fSDimitry Andric llvm::Value *DSTFi = Builder.CreateFDiv(T10, DpRC); // (br-a)/tmp
9495f757f3fSDimitry Andric Builder.CreateBr(ContBB);
9505f757f3fSDimitry Andric
9515f757f3fSDimitry Andric // Phi together the computation paths.
9525f757f3fSDimitry Andric CGF.EmitBlock(ContBB);
9535f757f3fSDimitry Andric llvm::PHINode *VALr = Builder.CreatePHI(DSTTr->getType(), 2);
9545f757f3fSDimitry Andric VALr->addIncoming(DSTTr, TrueBB);
9555f757f3fSDimitry Andric VALr->addIncoming(DSTFr, FalseBB);
9565f757f3fSDimitry Andric llvm::PHINode *VALi = Builder.CreatePHI(DSTTi->getType(), 2);
9575f757f3fSDimitry Andric VALi->addIncoming(DSTTi, TrueBB);
9585f757f3fSDimitry Andric VALi->addIncoming(DSTFi, FalseBB);
9595f757f3fSDimitry Andric return ComplexPairTy(VALr, VALi);
9605f757f3fSDimitry Andric }
9615f757f3fSDimitry Andric
9620b57cec5SDimitry Andric // See C11 Annex G.5.1 for the semantics of multiplicative operators on complex
9630b57cec5SDimitry Andric // typed values.
EmitBinDiv(const BinOpInfo & Op)9640b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) {
9650b57cec5SDimitry Andric llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second;
9660b57cec5SDimitry Andric llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second;
9670b57cec5SDimitry Andric llvm::Value *DSTr, *DSTi;
9680b57cec5SDimitry Andric if (LHSr->getType()->isFloatingPointTy()) {
9695f757f3fSDimitry Andric CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Op.FPFeatures);
9705f757f3fSDimitry Andric if (!RHSi) {
9715f757f3fSDimitry Andric assert(LHSi && "Can have at most one non-complex operand!");
9725f757f3fSDimitry Andric
9735f757f3fSDimitry Andric DSTr = Builder.CreateFDiv(LHSr, RHSr);
9745f757f3fSDimitry Andric DSTi = Builder.CreateFDiv(LHSi, RHSr);
9755f757f3fSDimitry Andric return ComplexPairTy(DSTr, DSTi);
9765f757f3fSDimitry Andric }
9775f757f3fSDimitry Andric llvm::Value *OrigLHSi = LHSi;
9785f757f3fSDimitry Andric if (!LHSi)
9795f757f3fSDimitry Andric LHSi = llvm::Constant::getNullValue(RHSi->getType());
9805f757f3fSDimitry Andric if (Op.FPFeatures.getComplexRange() == LangOptions::CX_Fortran)
9815f757f3fSDimitry Andric return EmitRangeReductionDiv(LHSr, LHSi, RHSr, RHSi);
9825f757f3fSDimitry Andric else if (Op.FPFeatures.getComplexRange() == LangOptions::CX_Limited)
9835f757f3fSDimitry Andric return EmitAlgebraicDiv(LHSr, LHSi, RHSr, RHSi);
9847a6dacacSDimitry Andric else if (!CGF.getLangOpts().FastMath ||
9857a6dacacSDimitry Andric // '-ffast-math' is used in the command line but followed by an
9867a6dacacSDimitry Andric // '-fno-cx-limited-range'.
9877a6dacacSDimitry Andric Op.FPFeatures.getComplexRange() == LangOptions::CX_Full) {
9885f757f3fSDimitry Andric LHSi = OrigLHSi;
9890b57cec5SDimitry Andric // If we have a complex operand on the RHS and FastMath is not allowed, we
9900b57cec5SDimitry Andric // delegate to a libcall to handle all of the complexities and minimize
9910b57cec5SDimitry Andric // underflow/overflow cases. When FastMath is allowed we construct the
9920b57cec5SDimitry Andric // divide inline using the same algorithm as for integer operands.
9930b57cec5SDimitry Andric //
9940b57cec5SDimitry Andric // FIXME: We would be able to avoid the libcall in many places if we
9950b57cec5SDimitry Andric // supported imaginary types in addition to complex types.
9960b57cec5SDimitry Andric BinOpInfo LibCallOp = Op;
9970b57cec5SDimitry Andric // If LHS was a real, supply a null imaginary part.
9980b57cec5SDimitry Andric if (!LHSi)
9990b57cec5SDimitry Andric LibCallOp.LHS.second = llvm::Constant::getNullValue(LHSr->getType());
10000b57cec5SDimitry Andric
10010b57cec5SDimitry Andric switch (LHSr->getType()->getTypeID()) {
10020b57cec5SDimitry Andric default:
10030b57cec5SDimitry Andric llvm_unreachable("Unsupported floating point type!");
10040b57cec5SDimitry Andric case llvm::Type::HalfTyID:
10050b57cec5SDimitry Andric return EmitComplexBinOpLibCall("__divhc3", LibCallOp);
10060b57cec5SDimitry Andric case llvm::Type::FloatTyID:
10070b57cec5SDimitry Andric return EmitComplexBinOpLibCall("__divsc3", LibCallOp);
10080b57cec5SDimitry Andric case llvm::Type::DoubleTyID:
10090b57cec5SDimitry Andric return EmitComplexBinOpLibCall("__divdc3", LibCallOp);
10100b57cec5SDimitry Andric case llvm::Type::PPC_FP128TyID:
10110b57cec5SDimitry Andric return EmitComplexBinOpLibCall("__divtc3", LibCallOp);
10120b57cec5SDimitry Andric case llvm::Type::X86_FP80TyID:
10130b57cec5SDimitry Andric return EmitComplexBinOpLibCall("__divxc3", LibCallOp);
10140b57cec5SDimitry Andric case llvm::Type::FP128TyID:
10150b57cec5SDimitry Andric return EmitComplexBinOpLibCall("__divtc3", LibCallOp);
10160b57cec5SDimitry Andric }
10170b57cec5SDimitry Andric } else {
10185f757f3fSDimitry Andric return EmitAlgebraicDiv(LHSr, LHSi, RHSr, RHSi);
10190b57cec5SDimitry Andric }
10200b57cec5SDimitry Andric } else {
10210b57cec5SDimitry Andric assert(Op.LHS.second && Op.RHS.second &&
10220b57cec5SDimitry Andric "Both operands of integer complex operators must be complex!");
10230b57cec5SDimitry Andric // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd))
10240b57cec5SDimitry Andric llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c
10250b57cec5SDimitry Andric llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d
10260b57cec5SDimitry Andric llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd
10270b57cec5SDimitry Andric
10280b57cec5SDimitry Andric llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c
10290b57cec5SDimitry Andric llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d
10300b57cec5SDimitry Andric llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd
10310b57cec5SDimitry Andric
10320b57cec5SDimitry Andric llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c
10330b57cec5SDimitry Andric llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d
10340b57cec5SDimitry Andric llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad
10350b57cec5SDimitry Andric
10360b57cec5SDimitry Andric if (Op.Ty->castAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) {
10370b57cec5SDimitry Andric DSTr = Builder.CreateUDiv(Tmp3, Tmp6);
10380b57cec5SDimitry Andric DSTi = Builder.CreateUDiv(Tmp9, Tmp6);
10390b57cec5SDimitry Andric } else {
10400b57cec5SDimitry Andric DSTr = Builder.CreateSDiv(Tmp3, Tmp6);
10410b57cec5SDimitry Andric DSTi = Builder.CreateSDiv(Tmp9, Tmp6);
10420b57cec5SDimitry Andric }
10430b57cec5SDimitry Andric }
10440b57cec5SDimitry Andric
10450b57cec5SDimitry Andric return ComplexPairTy(DSTr, DSTi);
10460b57cec5SDimitry Andric }
10470b57cec5SDimitry Andric
EmitUnPromotedValue(ComplexPairTy result,QualType UnPromotionType)1048bdd1243dSDimitry Andric ComplexPairTy CodeGenFunction::EmitUnPromotedValue(ComplexPairTy result,
1049bdd1243dSDimitry Andric QualType UnPromotionType) {
1050bdd1243dSDimitry Andric llvm::Type *ComplexElementTy =
1051bdd1243dSDimitry Andric ConvertType(UnPromotionType->castAs<ComplexType>()->getElementType());
1052bdd1243dSDimitry Andric if (result.first)
1053bdd1243dSDimitry Andric result.first =
1054bdd1243dSDimitry Andric Builder.CreateFPTrunc(result.first, ComplexElementTy, "unpromotion");
1055bdd1243dSDimitry Andric if (result.second)
1056bdd1243dSDimitry Andric result.second =
1057bdd1243dSDimitry Andric Builder.CreateFPTrunc(result.second, ComplexElementTy, "unpromotion");
1058bdd1243dSDimitry Andric return result;
1059bdd1243dSDimitry Andric }
1060bdd1243dSDimitry Andric
EmitPromotedValue(ComplexPairTy result,QualType PromotionType)1061bdd1243dSDimitry Andric ComplexPairTy CodeGenFunction::EmitPromotedValue(ComplexPairTy result,
1062bdd1243dSDimitry Andric QualType PromotionType) {
1063bdd1243dSDimitry Andric llvm::Type *ComplexElementTy =
1064bdd1243dSDimitry Andric ConvertType(PromotionType->castAs<ComplexType>()->getElementType());
1065bdd1243dSDimitry Andric if (result.first)
1066bdd1243dSDimitry Andric result.first = Builder.CreateFPExt(result.first, ComplexElementTy, "ext");
1067bdd1243dSDimitry Andric if (result.second)
1068bdd1243dSDimitry Andric result.second = Builder.CreateFPExt(result.second, ComplexElementTy, "ext");
1069bdd1243dSDimitry Andric
1070bdd1243dSDimitry Andric return result;
1071bdd1243dSDimitry Andric }
1072bdd1243dSDimitry Andric
EmitPromoted(const Expr * E,QualType PromotionType)1073bdd1243dSDimitry Andric ComplexPairTy ComplexExprEmitter::EmitPromoted(const Expr *E,
1074bdd1243dSDimitry Andric QualType PromotionType) {
1075bdd1243dSDimitry Andric E = E->IgnoreParens();
1076bdd1243dSDimitry Andric if (auto BO = dyn_cast<BinaryOperator>(E)) {
1077bdd1243dSDimitry Andric switch (BO->getOpcode()) {
1078bdd1243dSDimitry Andric #define HANDLE_BINOP(OP) \
1079bdd1243dSDimitry Andric case BO_##OP: \
1080bdd1243dSDimitry Andric return EmitBin##OP(EmitBinOps(BO, PromotionType));
1081bdd1243dSDimitry Andric HANDLE_BINOP(Add)
1082bdd1243dSDimitry Andric HANDLE_BINOP(Sub)
1083bdd1243dSDimitry Andric HANDLE_BINOP(Mul)
1084bdd1243dSDimitry Andric HANDLE_BINOP(Div)
1085bdd1243dSDimitry Andric #undef HANDLE_BINOP
1086bdd1243dSDimitry Andric default:
1087bdd1243dSDimitry Andric break;
1088bdd1243dSDimitry Andric }
1089bdd1243dSDimitry Andric } else if (auto UO = dyn_cast<UnaryOperator>(E)) {
1090bdd1243dSDimitry Andric switch (UO->getOpcode()) {
1091bdd1243dSDimitry Andric case UO_Minus:
1092bdd1243dSDimitry Andric return VisitMinus(UO, PromotionType);
1093bdd1243dSDimitry Andric case UO_Plus:
1094bdd1243dSDimitry Andric return VisitPlus(UO, PromotionType);
1095bdd1243dSDimitry Andric default:
1096bdd1243dSDimitry Andric break;
1097bdd1243dSDimitry Andric }
1098bdd1243dSDimitry Andric }
1099bdd1243dSDimitry Andric auto result = Visit(const_cast<Expr *>(E));
1100bdd1243dSDimitry Andric if (!PromotionType.isNull())
1101bdd1243dSDimitry Andric return CGF.EmitPromotedValue(result, PromotionType);
1102bdd1243dSDimitry Andric else
1103bdd1243dSDimitry Andric return result;
1104bdd1243dSDimitry Andric }
1105bdd1243dSDimitry Andric
EmitPromotedComplexExpr(const Expr * E,QualType DstTy)1106bdd1243dSDimitry Andric ComplexPairTy CodeGenFunction::EmitPromotedComplexExpr(const Expr *E,
1107bdd1243dSDimitry Andric QualType DstTy) {
1108bdd1243dSDimitry Andric return ComplexExprEmitter(*this).EmitPromoted(E, DstTy);
1109bdd1243dSDimitry Andric }
1110bdd1243dSDimitry Andric
1111bdd1243dSDimitry Andric ComplexPairTy
EmitPromotedComplexOperand(const Expr * E,QualType OverallPromotionType)1112bdd1243dSDimitry Andric ComplexExprEmitter::EmitPromotedComplexOperand(const Expr *E,
1113bdd1243dSDimitry Andric QualType OverallPromotionType) {
1114bdd1243dSDimitry Andric if (E->getType()->isAnyComplexType()) {
1115bdd1243dSDimitry Andric if (!OverallPromotionType.isNull())
1116bdd1243dSDimitry Andric return CGF.EmitPromotedComplexExpr(E, OverallPromotionType);
1117bdd1243dSDimitry Andric else
1118bdd1243dSDimitry Andric return Visit(const_cast<Expr *>(E));
1119bdd1243dSDimitry Andric } else {
1120bdd1243dSDimitry Andric if (!OverallPromotionType.isNull()) {
1121bdd1243dSDimitry Andric QualType ComplexElementTy =
1122bdd1243dSDimitry Andric OverallPromotionType->castAs<ComplexType>()->getElementType();
1123bdd1243dSDimitry Andric return ComplexPairTy(CGF.EmitPromotedScalarExpr(E, ComplexElementTy),
1124bdd1243dSDimitry Andric nullptr);
1125bdd1243dSDimitry Andric } else {
1126bdd1243dSDimitry Andric return ComplexPairTy(CGF.EmitScalarExpr(E), nullptr);
1127bdd1243dSDimitry Andric }
1128bdd1243dSDimitry Andric }
1129bdd1243dSDimitry Andric }
1130bdd1243dSDimitry Andric
11310b57cec5SDimitry Andric ComplexExprEmitter::BinOpInfo
EmitBinOps(const BinaryOperator * E,QualType PromotionType)1132bdd1243dSDimitry Andric ComplexExprEmitter::EmitBinOps(const BinaryOperator *E,
1133bdd1243dSDimitry Andric QualType PromotionType) {
11340b57cec5SDimitry Andric TestAndClearIgnoreReal();
11350b57cec5SDimitry Andric TestAndClearIgnoreImag();
11360b57cec5SDimitry Andric BinOpInfo Ops;
11370b57cec5SDimitry Andric
1138bdd1243dSDimitry Andric Ops.LHS = EmitPromotedComplexOperand(E->getLHS(), PromotionType);
1139bdd1243dSDimitry Andric Ops.RHS = EmitPromotedComplexOperand(E->getRHS(), PromotionType);
1140bdd1243dSDimitry Andric if (!PromotionType.isNull())
1141bdd1243dSDimitry Andric Ops.Ty = PromotionType;
1142bdd1243dSDimitry Andric else
11430b57cec5SDimitry Andric Ops.Ty = E->getType();
1144bdd1243dSDimitry Andric Ops.FPFeatures = E->getFPFeaturesInEffect(CGF.getLangOpts());
11450b57cec5SDimitry Andric return Ops;
11460b57cec5SDimitry Andric }
11470b57cec5SDimitry Andric
11480b57cec5SDimitry Andric
11490b57cec5SDimitry Andric LValue ComplexExprEmitter::
EmitCompoundAssignLValue(const CompoundAssignOperator * E,ComplexPairTy (ComplexExprEmitter::* Func)(const BinOpInfo &),RValue & Val)11500b57cec5SDimitry Andric EmitCompoundAssignLValue(const CompoundAssignOperator *E,
11510b57cec5SDimitry Andric ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&),
11520b57cec5SDimitry Andric RValue &Val) {
11530b57cec5SDimitry Andric TestAndClearIgnoreReal();
11540b57cec5SDimitry Andric TestAndClearIgnoreImag();
11550b57cec5SDimitry Andric QualType LHSTy = E->getLHS()->getType();
11560b57cec5SDimitry Andric if (const AtomicType *AT = LHSTy->getAs<AtomicType>())
11570b57cec5SDimitry Andric LHSTy = AT->getValueType();
11580b57cec5SDimitry Andric
11590b57cec5SDimitry Andric BinOpInfo OpInfo;
1160bdd1243dSDimitry Andric OpInfo.FPFeatures = E->getFPFeaturesInEffect(CGF.getLangOpts());
1161bdd1243dSDimitry Andric CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, OpInfo.FPFeatures);
11620b57cec5SDimitry Andric
11630b57cec5SDimitry Andric // Load the RHS and LHS operands.
11640b57cec5SDimitry Andric // __block variables need to have the rhs evaluated first, plus this should
11650b57cec5SDimitry Andric // improve codegen a little.
1166bdd1243dSDimitry Andric QualType PromotionTypeCR;
1167bdd1243dSDimitry Andric PromotionTypeCR = getPromotionType(E->getComputationResultType());
1168bdd1243dSDimitry Andric if (PromotionTypeCR.isNull())
1169bdd1243dSDimitry Andric PromotionTypeCR = E->getComputationResultType();
1170bdd1243dSDimitry Andric OpInfo.Ty = PromotionTypeCR;
1171bdd1243dSDimitry Andric QualType ComplexElementTy =
1172bdd1243dSDimitry Andric OpInfo.Ty->castAs<ComplexType>()->getElementType();
1173bdd1243dSDimitry Andric QualType PromotionTypeRHS = getPromotionType(E->getRHS()->getType());
11740b57cec5SDimitry Andric
11750b57cec5SDimitry Andric // The RHS should have been converted to the computation type.
11760b57cec5SDimitry Andric if (E->getRHS()->getType()->isRealFloatingType()) {
1177bdd1243dSDimitry Andric if (!PromotionTypeRHS.isNull())
1178bdd1243dSDimitry Andric OpInfo.RHS = ComplexPairTy(
1179bdd1243dSDimitry Andric CGF.EmitPromotedScalarExpr(E->getRHS(), PromotionTypeRHS), nullptr);
1180bdd1243dSDimitry Andric else {
1181bdd1243dSDimitry Andric assert(CGF.getContext().hasSameUnqualifiedType(ComplexElementTy,
1182bdd1243dSDimitry Andric E->getRHS()->getType()));
1183bdd1243dSDimitry Andric
11840b57cec5SDimitry Andric OpInfo.RHS = ComplexPairTy(CGF.EmitScalarExpr(E->getRHS()), nullptr);
1185bdd1243dSDimitry Andric }
11860b57cec5SDimitry Andric } else {
1187bdd1243dSDimitry Andric if (!PromotionTypeRHS.isNull()) {
1188bdd1243dSDimitry Andric OpInfo.RHS = ComplexPairTy(
1189bdd1243dSDimitry Andric CGF.EmitPromotedComplexExpr(E->getRHS(), PromotionTypeRHS));
1190bdd1243dSDimitry Andric } else {
1191bdd1243dSDimitry Andric assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty,
1192bdd1243dSDimitry Andric E->getRHS()->getType()));
11930b57cec5SDimitry Andric OpInfo.RHS = Visit(E->getRHS());
11940b57cec5SDimitry Andric }
1195bdd1243dSDimitry Andric }
11960b57cec5SDimitry Andric
11970b57cec5SDimitry Andric LValue LHS = CGF.EmitLValue(E->getLHS());
11980b57cec5SDimitry Andric
11990b57cec5SDimitry Andric // Load from the l-value and convert it.
12000b57cec5SDimitry Andric SourceLocation Loc = E->getExprLoc();
1201bdd1243dSDimitry Andric QualType PromotionTypeLHS = getPromotionType(E->getComputationLHSType());
12020b57cec5SDimitry Andric if (LHSTy->isAnyComplexType()) {
12030b57cec5SDimitry Andric ComplexPairTy LHSVal = EmitLoadOfLValue(LHS, Loc);
1204bdd1243dSDimitry Andric if (!PromotionTypeLHS.isNull())
1205bdd1243dSDimitry Andric OpInfo.LHS =
1206bdd1243dSDimitry Andric EmitComplexToComplexCast(LHSVal, LHSTy, PromotionTypeLHS, Loc);
1207bdd1243dSDimitry Andric else
12080b57cec5SDimitry Andric OpInfo.LHS = EmitComplexToComplexCast(LHSVal, LHSTy, OpInfo.Ty, Loc);
12090b57cec5SDimitry Andric } else {
12100b57cec5SDimitry Andric llvm::Value *LHSVal = CGF.EmitLoadOfScalar(LHS, Loc);
12110b57cec5SDimitry Andric // For floating point real operands we can directly pass the scalar form
12120b57cec5SDimitry Andric // to the binary operator emission and potentially get more efficient code.
12130b57cec5SDimitry Andric if (LHSTy->isRealFloatingType()) {
1214bdd1243dSDimitry Andric QualType PromotedComplexElementTy;
1215bdd1243dSDimitry Andric if (!PromotionTypeLHS.isNull()) {
1216bdd1243dSDimitry Andric PromotedComplexElementTy =
1217bdd1243dSDimitry Andric cast<ComplexType>(PromotionTypeLHS)->getElementType();
1218bdd1243dSDimitry Andric if (!CGF.getContext().hasSameUnqualifiedType(PromotedComplexElementTy,
1219bdd1243dSDimitry Andric PromotionTypeLHS))
1220bdd1243dSDimitry Andric LHSVal = CGF.EmitScalarConversion(LHSVal, LHSTy,
1221bdd1243dSDimitry Andric PromotedComplexElementTy, Loc);
1222bdd1243dSDimitry Andric } else {
12230b57cec5SDimitry Andric if (!CGF.getContext().hasSameUnqualifiedType(ComplexElementTy, LHSTy))
1224bdd1243dSDimitry Andric LHSVal =
1225bdd1243dSDimitry Andric CGF.EmitScalarConversion(LHSVal, LHSTy, ComplexElementTy, Loc);
1226bdd1243dSDimitry Andric }
12270b57cec5SDimitry Andric OpInfo.LHS = ComplexPairTy(LHSVal, nullptr);
12280b57cec5SDimitry Andric } else {
12290b57cec5SDimitry Andric OpInfo.LHS = EmitScalarToComplexCast(LHSVal, LHSTy, OpInfo.Ty, Loc);
12300b57cec5SDimitry Andric }
12310b57cec5SDimitry Andric }
12320b57cec5SDimitry Andric
12330b57cec5SDimitry Andric // Expand the binary operator.
12340b57cec5SDimitry Andric ComplexPairTy Result = (this->*Func)(OpInfo);
12350b57cec5SDimitry Andric
12360b57cec5SDimitry Andric // Truncate the result and store it into the LHS lvalue.
12370b57cec5SDimitry Andric if (LHSTy->isAnyComplexType()) {
12380b57cec5SDimitry Andric ComplexPairTy ResVal =
12390b57cec5SDimitry Andric EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy, Loc);
12400b57cec5SDimitry Andric EmitStoreOfComplex(ResVal, LHS, /*isInit*/ false);
12410b57cec5SDimitry Andric Val = RValue::getComplex(ResVal);
12420b57cec5SDimitry Andric } else {
12430b57cec5SDimitry Andric llvm::Value *ResVal =
12440b57cec5SDimitry Andric CGF.EmitComplexToScalarConversion(Result, OpInfo.Ty, LHSTy, Loc);
12450b57cec5SDimitry Andric CGF.EmitStoreOfScalar(ResVal, LHS, /*isInit*/ false);
12460b57cec5SDimitry Andric Val = RValue::get(ResVal);
12470b57cec5SDimitry Andric }
12480b57cec5SDimitry Andric
12490b57cec5SDimitry Andric return LHS;
12500b57cec5SDimitry Andric }
12510b57cec5SDimitry Andric
12520b57cec5SDimitry Andric // Compound assignments.
12530b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::
EmitCompoundAssign(const CompoundAssignOperator * E,ComplexPairTy (ComplexExprEmitter::* Func)(const BinOpInfo &))12540b57cec5SDimitry Andric EmitCompoundAssign(const CompoundAssignOperator *E,
12550b57cec5SDimitry Andric ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){
12560b57cec5SDimitry Andric RValue Val;
12570b57cec5SDimitry Andric LValue LV = EmitCompoundAssignLValue(E, Func, Val);
12580b57cec5SDimitry Andric
12590b57cec5SDimitry Andric // The result of an assignment in C is the assigned r-value.
12600b57cec5SDimitry Andric if (!CGF.getLangOpts().CPlusPlus)
12610b57cec5SDimitry Andric return Val.getComplexVal();
12620b57cec5SDimitry Andric
12630b57cec5SDimitry Andric // If the lvalue is non-volatile, return the computed value of the assignment.
12640b57cec5SDimitry Andric if (!LV.isVolatileQualified())
12650b57cec5SDimitry Andric return Val.getComplexVal();
12660b57cec5SDimitry Andric
12670b57cec5SDimitry Andric return EmitLoadOfLValue(LV, E->getExprLoc());
12680b57cec5SDimitry Andric }
12690b57cec5SDimitry Andric
EmitBinAssignLValue(const BinaryOperator * E,ComplexPairTy & Val)12700b57cec5SDimitry Andric LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E,
12710b57cec5SDimitry Andric ComplexPairTy &Val) {
12720b57cec5SDimitry Andric assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
12730b57cec5SDimitry Andric E->getRHS()->getType()) &&
12740b57cec5SDimitry Andric "Invalid assignment");
12750b57cec5SDimitry Andric TestAndClearIgnoreReal();
12760b57cec5SDimitry Andric TestAndClearIgnoreImag();
12770b57cec5SDimitry Andric
12780b57cec5SDimitry Andric // Emit the RHS. __block variables need the RHS evaluated first.
12790b57cec5SDimitry Andric Val = Visit(E->getRHS());
12800b57cec5SDimitry Andric
12810b57cec5SDimitry Andric // Compute the address to store into.
12820b57cec5SDimitry Andric LValue LHS = CGF.EmitLValue(E->getLHS());
12830b57cec5SDimitry Andric
12840b57cec5SDimitry Andric // Store the result value into the LHS lvalue.
12850b57cec5SDimitry Andric EmitStoreOfComplex(Val, LHS, /*isInit*/ false);
12860b57cec5SDimitry Andric
12870b57cec5SDimitry Andric return LHS;
12880b57cec5SDimitry Andric }
12890b57cec5SDimitry Andric
VisitBinAssign(const BinaryOperator * E)12900b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) {
12910b57cec5SDimitry Andric ComplexPairTy Val;
12920b57cec5SDimitry Andric LValue LV = EmitBinAssignLValue(E, Val);
12930b57cec5SDimitry Andric
12940b57cec5SDimitry Andric // The result of an assignment in C is the assigned r-value.
12950b57cec5SDimitry Andric if (!CGF.getLangOpts().CPlusPlus)
12960b57cec5SDimitry Andric return Val;
12970b57cec5SDimitry Andric
12980b57cec5SDimitry Andric // If the lvalue is non-volatile, return the computed value of the assignment.
12990b57cec5SDimitry Andric if (!LV.isVolatileQualified())
13000b57cec5SDimitry Andric return Val;
13010b57cec5SDimitry Andric
13020b57cec5SDimitry Andric return EmitLoadOfLValue(LV, E->getExprLoc());
13030b57cec5SDimitry Andric }
13040b57cec5SDimitry Andric
VisitBinComma(const BinaryOperator * E)13050b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) {
13060b57cec5SDimitry Andric CGF.EmitIgnoredExpr(E->getLHS());
13070b57cec5SDimitry Andric return Visit(E->getRHS());
13080b57cec5SDimitry Andric }
13090b57cec5SDimitry Andric
13100b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::
VisitAbstractConditionalOperator(const AbstractConditionalOperator * E)13110b57cec5SDimitry Andric VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
13120b57cec5SDimitry Andric TestAndClearIgnoreReal();
13130b57cec5SDimitry Andric TestAndClearIgnoreImag();
13140b57cec5SDimitry Andric llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true");
13150b57cec5SDimitry Andric llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false");
13160b57cec5SDimitry Andric llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end");
13170b57cec5SDimitry Andric
13180b57cec5SDimitry Andric // Bind the common expression if necessary.
13190b57cec5SDimitry Andric CodeGenFunction::OpaqueValueMapping binding(CGF, E);
13200b57cec5SDimitry Andric
13210b57cec5SDimitry Andric
13220b57cec5SDimitry Andric CodeGenFunction::ConditionalEvaluation eval(CGF);
13230b57cec5SDimitry Andric CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock,
13240b57cec5SDimitry Andric CGF.getProfileCount(E));
13250b57cec5SDimitry Andric
13260b57cec5SDimitry Andric eval.begin(CGF);
13270b57cec5SDimitry Andric CGF.EmitBlock(LHSBlock);
13280b57cec5SDimitry Andric CGF.incrementProfileCounter(E);
13290b57cec5SDimitry Andric ComplexPairTy LHS = Visit(E->getTrueExpr());
13300b57cec5SDimitry Andric LHSBlock = Builder.GetInsertBlock();
13310b57cec5SDimitry Andric CGF.EmitBranch(ContBlock);
13320b57cec5SDimitry Andric eval.end(CGF);
13330b57cec5SDimitry Andric
13340b57cec5SDimitry Andric eval.begin(CGF);
13350b57cec5SDimitry Andric CGF.EmitBlock(RHSBlock);
13360b57cec5SDimitry Andric ComplexPairTy RHS = Visit(E->getFalseExpr());
13370b57cec5SDimitry Andric RHSBlock = Builder.GetInsertBlock();
13380b57cec5SDimitry Andric CGF.EmitBlock(ContBlock);
13390b57cec5SDimitry Andric eval.end(CGF);
13400b57cec5SDimitry Andric
13410b57cec5SDimitry Andric // Create a PHI node for the real part.
13420b57cec5SDimitry Andric llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r");
13430b57cec5SDimitry Andric RealPN->addIncoming(LHS.first, LHSBlock);
13440b57cec5SDimitry Andric RealPN->addIncoming(RHS.first, RHSBlock);
13450b57cec5SDimitry Andric
13460b57cec5SDimitry Andric // Create a PHI node for the imaginary part.
13470b57cec5SDimitry Andric llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i");
13480b57cec5SDimitry Andric ImagPN->addIncoming(LHS.second, LHSBlock);
13490b57cec5SDimitry Andric ImagPN->addIncoming(RHS.second, RHSBlock);
13500b57cec5SDimitry Andric
13510b57cec5SDimitry Andric return ComplexPairTy(RealPN, ImagPN);
13520b57cec5SDimitry Andric }
13530b57cec5SDimitry Andric
VisitChooseExpr(ChooseExpr * E)13540b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) {
13550b57cec5SDimitry Andric return Visit(E->getChosenSubExpr());
13560b57cec5SDimitry Andric }
13570b57cec5SDimitry Andric
VisitInitListExpr(InitListExpr * E)13580b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
13590b57cec5SDimitry Andric bool Ignore = TestAndClearIgnoreReal();
13600b57cec5SDimitry Andric (void)Ignore;
13610b57cec5SDimitry Andric assert (Ignore == false && "init list ignored");
13620b57cec5SDimitry Andric Ignore = TestAndClearIgnoreImag();
13630b57cec5SDimitry Andric (void)Ignore;
13640b57cec5SDimitry Andric assert (Ignore == false && "init list ignored");
13650b57cec5SDimitry Andric
13660b57cec5SDimitry Andric if (E->getNumInits() == 2) {
13670b57cec5SDimitry Andric llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0));
13680b57cec5SDimitry Andric llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1));
13690b57cec5SDimitry Andric return ComplexPairTy(Real, Imag);
13700b57cec5SDimitry Andric } else if (E->getNumInits() == 1) {
13710b57cec5SDimitry Andric return Visit(E->getInit(0));
13720b57cec5SDimitry Andric }
13730b57cec5SDimitry Andric
13740b57cec5SDimitry Andric // Empty init list initializes to null
13750b57cec5SDimitry Andric assert(E->getNumInits() == 0 && "Unexpected number of inits");
13760b57cec5SDimitry Andric QualType Ty = E->getType()->castAs<ComplexType>()->getElementType();
13770b57cec5SDimitry Andric llvm::Type* LTy = CGF.ConvertType(Ty);
13780b57cec5SDimitry Andric llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
13790b57cec5SDimitry Andric return ComplexPairTy(zeroConstant, zeroConstant);
13800b57cec5SDimitry Andric }
13810b57cec5SDimitry Andric
VisitVAArgExpr(VAArgExpr * E)13820b57cec5SDimitry Andric ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
13830b57cec5SDimitry Andric Address ArgValue = Address::invalid();
13840b57cec5SDimitry Andric Address ArgPtr = CGF.EmitVAArg(E, ArgValue);
13850b57cec5SDimitry Andric
13860b57cec5SDimitry Andric if (!ArgPtr.isValid()) {
13870b57cec5SDimitry Andric CGF.ErrorUnsupported(E, "complex va_arg expression");
13880b57cec5SDimitry Andric llvm::Type *EltTy =
13890b57cec5SDimitry Andric CGF.ConvertType(E->getType()->castAs<ComplexType>()->getElementType());
13900b57cec5SDimitry Andric llvm::Value *U = llvm::UndefValue::get(EltTy);
13910b57cec5SDimitry Andric return ComplexPairTy(U, U);
13920b57cec5SDimitry Andric }
13930b57cec5SDimitry Andric
13940b57cec5SDimitry Andric return EmitLoadOfLValue(CGF.MakeAddrLValue(ArgPtr, E->getType()),
13950b57cec5SDimitry Andric E->getExprLoc());
13960b57cec5SDimitry Andric }
13970b57cec5SDimitry Andric
13980b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
13990b57cec5SDimitry Andric // Entry Point into this File
14000b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
14010b57cec5SDimitry Andric
14020b57cec5SDimitry Andric /// EmitComplexExpr - Emit the computation of the specified expression of
14030b57cec5SDimitry Andric /// complex type, ignoring the result.
EmitComplexExpr(const Expr * E,bool IgnoreReal,bool IgnoreImag)14040b57cec5SDimitry Andric ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal,
14050b57cec5SDimitry Andric bool IgnoreImag) {
14060b57cec5SDimitry Andric assert(E && getComplexType(E->getType()) &&
14070b57cec5SDimitry Andric "Invalid complex expression to emit");
14080b57cec5SDimitry Andric
14090b57cec5SDimitry Andric return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag)
14100b57cec5SDimitry Andric .Visit(const_cast<Expr *>(E));
14110b57cec5SDimitry Andric }
14120b57cec5SDimitry Andric
EmitComplexExprIntoLValue(const Expr * E,LValue dest,bool isInit)14130b57cec5SDimitry Andric void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest,
14140b57cec5SDimitry Andric bool isInit) {
14150b57cec5SDimitry Andric assert(E && getComplexType(E->getType()) &&
14160b57cec5SDimitry Andric "Invalid complex expression to emit");
14170b57cec5SDimitry Andric ComplexExprEmitter Emitter(*this);
14180b57cec5SDimitry Andric ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E));
14190b57cec5SDimitry Andric Emitter.EmitStoreOfComplex(Val, dest, isInit);
14200b57cec5SDimitry Andric }
14210b57cec5SDimitry Andric
14220b57cec5SDimitry Andric /// EmitStoreOfComplex - Store a complex number into the specified l-value.
EmitStoreOfComplex(ComplexPairTy V,LValue dest,bool isInit)14230b57cec5SDimitry Andric void CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue dest,
14240b57cec5SDimitry Andric bool isInit) {
14250b57cec5SDimitry Andric ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit);
14260b57cec5SDimitry Andric }
14270b57cec5SDimitry Andric
14280b57cec5SDimitry Andric /// EmitLoadOfComplex - Load a complex number from the specified address.
EmitLoadOfComplex(LValue src,SourceLocation loc)14290b57cec5SDimitry Andric ComplexPairTy CodeGenFunction::EmitLoadOfComplex(LValue src,
14300b57cec5SDimitry Andric SourceLocation loc) {
14310b57cec5SDimitry Andric return ComplexExprEmitter(*this).EmitLoadOfLValue(src, loc);
14320b57cec5SDimitry Andric }
14330b57cec5SDimitry Andric
EmitComplexAssignmentLValue(const BinaryOperator * E)14340b57cec5SDimitry Andric LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) {
14350b57cec5SDimitry Andric assert(E->getOpcode() == BO_Assign);
14360b57cec5SDimitry Andric ComplexPairTy Val; // ignored
1437480093f4SDimitry Andric LValue LVal = ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val);
1438480093f4SDimitry Andric if (getLangOpts().OpenMP)
1439480093f4SDimitry Andric CGM.getOpenMPRuntime().checkAndEmitLastprivateConditional(*this,
1440480093f4SDimitry Andric E->getLHS());
1441480093f4SDimitry Andric return LVal;
14420b57cec5SDimitry Andric }
14430b57cec5SDimitry Andric
14440b57cec5SDimitry Andric typedef ComplexPairTy (ComplexExprEmitter::*CompoundFunc)(
14450b57cec5SDimitry Andric const ComplexExprEmitter::BinOpInfo &);
14460b57cec5SDimitry Andric
getComplexOp(BinaryOperatorKind Op)14470b57cec5SDimitry Andric static CompoundFunc getComplexOp(BinaryOperatorKind Op) {
14480b57cec5SDimitry Andric switch (Op) {
14490b57cec5SDimitry Andric case BO_MulAssign: return &ComplexExprEmitter::EmitBinMul;
14500b57cec5SDimitry Andric case BO_DivAssign: return &ComplexExprEmitter::EmitBinDiv;
14510b57cec5SDimitry Andric case BO_SubAssign: return &ComplexExprEmitter::EmitBinSub;
14520b57cec5SDimitry Andric case BO_AddAssign: return &ComplexExprEmitter::EmitBinAdd;
14530b57cec5SDimitry Andric default:
14540b57cec5SDimitry Andric llvm_unreachable("unexpected complex compound assignment");
14550b57cec5SDimitry Andric }
14560b57cec5SDimitry Andric }
14570b57cec5SDimitry Andric
14580b57cec5SDimitry Andric LValue CodeGenFunction::
EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator * E)14590b57cec5SDimitry Andric EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) {
14600b57cec5SDimitry Andric CompoundFunc Op = getComplexOp(E->getOpcode());
14610b57cec5SDimitry Andric RValue Val;
14620b57cec5SDimitry Andric return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
14630b57cec5SDimitry Andric }
14640b57cec5SDimitry Andric
14650b57cec5SDimitry Andric LValue CodeGenFunction::
EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator * E,llvm::Value * & Result)14660b57cec5SDimitry Andric EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E,
14670b57cec5SDimitry Andric llvm::Value *&Result) {
14680b57cec5SDimitry Andric CompoundFunc Op = getComplexOp(E->getOpcode());
14690b57cec5SDimitry Andric RValue Val;
14700b57cec5SDimitry Andric LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val);
14710b57cec5SDimitry Andric Result = Val.getScalarVal();
14720b57cec5SDimitry Andric return Ret;
14730b57cec5SDimitry Andric }
1474