Lines Matching +full:e +full:- +full:ddc
1 //===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
11 //===----------------------------------------------------------------------===//
27 //===----------------------------------------------------------------------===//
29 //===----------------------------------------------------------------------===//
43 return cast<ComplexType>(cast<AtomicType>(type)->getValueType()); in getComplexType()
61 //===--------------------------------------------------------------------===//
63 //===--------------------------------------------------------------------===//
76 /// EmitLoadOfLValue - Given an expression with complex type that represents a
77 /// value l-value, this method emits the address of the l-value, then loads
79 ComplexPairTy EmitLoadOfLValue(const Expr *E) { in EmitLoadOfLValue() argument
80 return EmitLoadOfLValue(CGF.EmitLValue(E), E->getExprLoc()); in EmitLoadOfLValue()
85 /// EmitStoreOfComplex - Store the specified real/imag parts into the
96 //===--------------------------------------------------------------------===//
98 //===--------------------------------------------------------------------===//
100 ComplexPairTy Visit(Expr *E) { in Visit() argument
101 ApplyDebugLocation DL(CGF, E); in Visit()
102 return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E); in Visit()
106 S->dump(llvm::errs(), CGF.getContext()); in VisitStmt()
110 ComplexPairTy VisitConstantExpr(ConstantExpr *E) { in VisitConstantExpr() argument
111 if (llvm::Constant *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E)) in VisitConstantExpr()
112 return ComplexPairTy(Result->getAggregateElement(0U), in VisitConstantExpr()
113 Result->getAggregateElement(1U)); in VisitConstantExpr()
114 return Visit(E->getSubExpr()); in VisitConstantExpr()
116 ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());} in VisitParenExpr()
118 return Visit(GE->getResultExpr()); in VisitGenericSelectionExpr()
123 return Visit(PE->getReplacement()); in VisitSubstNonTypeTemplateParmExpr()
131 ComplexPairTy VisitUnaryCoawait(const UnaryOperator *E) { in VisitUnaryCoawait() argument
132 return Visit(E->getSubExpr()); in VisitUnaryCoawait()
136 Expr *E) { in emitConstant() argument
139 return EmitLoadOfLValue(Constant.getReferenceLValue(CGF, E), in emitConstant()
140 E->getExprLoc()); in emitConstant()
143 return ComplexPairTy(pair->getAggregateElement(0U), in emitConstant()
144 pair->getAggregateElement(1U)); in emitConstant()
147 // l-values.
148 ComplexPairTy VisitDeclRefExpr(DeclRefExpr *E) { in VisitDeclRefExpr() argument
149 if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E)) in VisitDeclRefExpr()
150 return emitConstant(Constant, E); in VisitDeclRefExpr()
151 return EmitLoadOfLValue(E); in VisitDeclRefExpr()
153 ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { in VisitObjCIvarRefExpr() argument
154 return EmitLoadOfLValue(E); in VisitObjCIvarRefExpr()
156 ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) { in VisitObjCMessageExpr() argument
157 return CGF.EmitObjCMessageExpr(E).getComplexVal(); in VisitObjCMessageExpr()
159 ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); } in VisitArraySubscriptExpr() argument
163 CGF.EmitIgnoredExpr(ME->getBase()); in VisitMemberExpr()
168 ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) { in VisitOpaqueValueExpr() argument
169 if (E->isGLValue()) in VisitOpaqueValueExpr()
170 return EmitLoadOfLValue(CGF.getOrCreateOpaqueLValueMapping(E), in VisitOpaqueValueExpr()
171 E->getExprLoc()); in VisitOpaqueValueExpr()
172 return CGF.getOrCreateOpaqueRValueMapping(E).getComplexVal(); in VisitOpaqueValueExpr()
175 ComplexPairTy VisitPseudoObjectExpr(PseudoObjectExpr *E) { in VisitPseudoObjectExpr() argument
176 return CGF.EmitPseudoObjectRValue(E).getComplexVal(); in VisitPseudoObjectExpr()
182 ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) { in VisitImplicitCastExpr() argument
183 // Unlike for scalars, we don't have to worry about function->ptr demotion in VisitImplicitCastExpr()
185 if (E->changesVolatileQualification()) in VisitImplicitCastExpr()
186 return EmitLoadOfLValue(E); in VisitImplicitCastExpr()
187 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); in VisitImplicitCastExpr()
189 ComplexPairTy VisitCastExpr(CastExpr *E) { in VisitCastExpr() argument
190 if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E)) in VisitCastExpr()
192 if (E->changesVolatileQualification()) in VisitCastExpr()
193 return EmitLoadOfLValue(E); in VisitCastExpr()
194 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); in VisitCastExpr()
196 ComplexPairTy VisitCallExpr(const CallExpr *E);
197 ComplexPairTy VisitStmtExpr(const StmtExpr *E);
200 ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E, in VisitPrePostIncDec() argument
202 LValue LV = CGF.EmitLValue(E->getSubExpr()); in VisitPrePostIncDec()
203 return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre); in VisitPrePostIncDec()
205 ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) { in VisitUnaryPostDec() argument
206 return VisitPrePostIncDec(E, false, false); in VisitUnaryPostDec()
208 ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) { in VisitUnaryPostInc() argument
209 return VisitPrePostIncDec(E, true, false); in VisitUnaryPostInc()
211 ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) { in VisitUnaryPreDec() argument
212 return VisitPrePostIncDec(E, false, true); in VisitUnaryPreDec()
214 ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) { in VisitUnaryPreInc() argument
215 return VisitPrePostIncDec(E, true, true); in VisitUnaryPreInc()
217 ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } in VisitUnaryDeref() argument
219 ComplexPairTy VisitUnaryPlus(const UnaryOperator *E,
221 ComplexPairTy VisitPlus(const UnaryOperator *E, QualType PromotionType);
222 ComplexPairTy VisitUnaryMinus(const UnaryOperator *E,
224 ComplexPairTy VisitMinus(const UnaryOperator *E, QualType PromotionType);
225 ComplexPairTy VisitUnaryNot (const UnaryOperator *E);
227 ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) { in VisitUnaryExtension() argument
228 return Visit(E->getSubExpr()); in VisitUnaryExtension()
232 return Visit(DAE->getExpr()); in VisitCXXDefaultArgExpr()
236 return Visit(DIE->getExpr()); in VisitCXXDefaultInitExpr()
238 ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) { in VisitExprWithCleanups() argument
240 ComplexPairTy Vals = Visit(E->getSubExpr()); in VisitExprWithCleanups()
246 ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { in VisitCXXScalarValueInitExpr() argument
247 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); in VisitCXXScalarValueInitExpr()
248 QualType Elem = E->getType()->castAs<ComplexType>()->getElementType(); in VisitCXXScalarValueInitExpr()
252 ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { in VisitImplicitValueInitExpr() argument
253 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); in VisitImplicitValueInitExpr()
254 QualType Elem = E->getType()->castAs<ComplexType>()->getElementType(); in VisitImplicitValueInitExpr()
267 BinOpInfo EmitBinOps(const BinaryOperator *E,
269 ComplexPairTy EmitPromoted(const Expr *E, QualType PromotionTy);
270 ComplexPairTy EmitPromotedComplexOperand(const Expr *E, QualType PromotionTy);
271 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
275 ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E,
293 switch (CurrentBT->getKind()) { in GetHigherPrecisionFPType()
333 if (auto *CT = Ty->getAs<ComplexType>()) { in getPromotionType()
334 QualType ElementType = CT->getElementType(); in getPromotionType()
335 bool IsFloatingType = ElementType->isFloatingType(); in getPromotionType()
356 ComplexPairTy VisitBin##OP(const BinaryOperator *E) { \
358 E->getStoredFPFeaturesOrDefault(), E->getType(), \
359 (E->getOpcode() == BinaryOperatorKind::BO_Div) ? true : false); \
360 ComplexPairTy result = EmitBin##OP(EmitBinOps(E, promotionTy)); \
362 result = CGF.EmitUnPromotedValue(result, E->getType()); \
372 ComplexPairTy VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) { in HANDLEBINOP()
373 return Visit(E->getSemanticForm()); in HANDLEBINOP()
377 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) { in VisitBinAddAssign() argument
378 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd); in VisitBinAddAssign()
380 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) { in VisitBinSubAssign() argument
381 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub); in VisitBinSubAssign()
383 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) { in VisitBinMulAssign() argument
384 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul); in VisitBinMulAssign()
386 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) { in VisitBinDivAssign() argument
387 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv); in VisitBinDivAssign()
395 LValue EmitBinAssignLValue(const BinaryOperator *E,
397 ComplexPairTy VisitBinAssign (const BinaryOperator *E);
398 ComplexPairTy VisitBinComma (const BinaryOperator *E);
405 ComplexPairTy VisitInitListExpr(InitListExpr *E);
407 ComplexPairTy VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { in VisitCompoundLiteralExpr() argument
408 return EmitLoadOfLValue(E); in VisitCompoundLiteralExpr()
411 ComplexPairTy VisitVAArgExpr(VAArgExpr *E);
413 ComplexPairTy VisitAtomicExpr(AtomicExpr *E) { in VisitAtomicExpr() argument
414 return CGF.EmitAtomicExpr(E).getComplexVal(); in VisitAtomicExpr()
417 ComplexPairTy VisitPackIndexingExpr(PackIndexingExpr *E) { in VisitPackIndexingExpr() argument
418 return Visit(E->getSelectedExpr()); in VisitPackIndexingExpr()
423 //===----------------------------------------------------------------------===//
425 //===----------------------------------------------------------------------===//
437 /// EmitLoadOfLValue - Given an RValue reference for a complex, emit code to
441 assert(lvalue.isSimple() && "non-simple complex l-value?"); in EmitLoadOfLValue()
442 if (lvalue.getType()->isAtomicType()) in EmitLoadOfLValue()
463 /// EmitStoreOfComplex - Store the specified real/imag parts into the
467 if (lvalue.getType()->isAtomicType() || in EmitStoreOfComplex()
481 //===----------------------------------------------------------------------===//
483 //===----------------------------------------------------------------------===//
485 ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) { in VisitExpr() argument
486 CGF.ErrorUnsupported(E, "complex expression"); in VisitExpr()
488 CGF.ConvertType(getComplexType(E->getType())->getElementType()); in VisitExpr()
495 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr()); in VisitImaginaryLiteral()
496 return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag); in VisitImaginaryLiteral()
500 ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) { in VisitCallExpr() argument
501 if (E->getCallReturnType(CGF.getContext())->isReferenceType()) in VisitCallExpr()
502 return EmitLoadOfLValue(E); in VisitCallExpr()
504 return CGF.EmitCallExpr(E).getComplexVal(); in VisitCallExpr()
507 ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) { in VisitStmtExpr() argument
509 Address RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(), true); in VisitStmtExpr()
511 return EmitLoadOfLValue(CGF.MakeAddrLValue(RetAlloca, E->getType()), in VisitStmtExpr()
512 E->getExprLoc()); in VisitStmtExpr()
521 SrcType = SrcType->castAs<ComplexType>()->getElementType(); in EmitComplexToComplexCast()
522 DestType = DestType->castAs<ComplexType>()->getElementType(); in EmitComplexToComplexCast()
539 DestType = DestType->castAs<ComplexType>()->getElementType(); in EmitScalarToComplexCast()
543 return ComplexPairTy(Val, llvm::Constant::getNullValue(Val->getType())); in EmitScalarToComplexCast()
551 // Atomic to non-atomic casts may be more than a no-op for some platforms and in EmitCast()
563 return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy), Op->getExprLoc()); in EmitCast()
572 return EmitLoadOfLValue(DestLV, Op->getExprLoc()); in EmitCast()
633 return EmitScalarToComplexCast(CGF.EmitScalarExpr(Op), Op->getType(), in EmitCast()
634 DestTy, Op->getExprLoc()); in EmitCast()
642 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy, in EmitCast()
643 Op->getExprLoc()); in EmitCast()
650 ComplexPairTy ComplexExprEmitter::VisitUnaryPlus(const UnaryOperator *E, in VisitUnaryPlus() argument
652 E->hasStoredFPFeatures(); in VisitUnaryPlus()
655 ? getPromotionType(E->getStoredFPFeaturesOrDefault(), in VisitUnaryPlus()
656 E->getSubExpr()->getType()) in VisitUnaryPlus()
658 ComplexPairTy result = VisitPlus(E, promotionTy); in VisitUnaryPlus()
660 return CGF.EmitUnPromotedValue(result, E->getSubExpr()->getType()); in VisitUnaryPlus()
664 ComplexPairTy ComplexExprEmitter::VisitPlus(const UnaryOperator *E, in VisitPlus() argument
669 return CGF.EmitPromotedComplexExpr(E->getSubExpr(), PromotionType); in VisitPlus()
670 return Visit(E->getSubExpr()); in VisitPlus()
673 ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E, in VisitUnaryMinus() argument
677 ? getPromotionType(E->getStoredFPFeaturesOrDefault(), in VisitUnaryMinus()
678 E->getSubExpr()->getType()) in VisitUnaryMinus()
680 ComplexPairTy result = VisitMinus(E, promotionTy); in VisitUnaryMinus()
682 return CGF.EmitUnPromotedValue(result, E->getSubExpr()->getType()); in VisitUnaryMinus()
685 ComplexPairTy ComplexExprEmitter::VisitMinus(const UnaryOperator *E, in VisitMinus() argument
691 Op = CGF.EmitPromotedComplexExpr(E->getSubExpr(), PromotionType); in VisitMinus()
693 Op = Visit(E->getSubExpr()); in VisitMinus()
696 if (Op.first->getType()->isFloatingPointTy()) { in VisitMinus()
706 ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { in VisitUnaryNot() argument
709 // ~(a+ib) = a + i*-b in VisitUnaryNot()
710 ComplexPairTy Op = Visit(E->getSubExpr()); in VisitUnaryNot()
712 if (Op.second->getType()->isFloatingPointTy()) in VisitUnaryNot()
723 if (Op.LHS.first->getType()->isFloatingPointTy()) { in EmitBinAdd()
742 if (Op.LHS.first->getType()->isFloatingPointTy()) { in EmitBinSub()
765 Op.Ty->castAs<ComplexType>()->getElementType()); in EmitComplexBinOpLibCall()
767 Op.Ty->castAs<ComplexType>()->getElementType()); in EmitComplexBinOpLibCall()
769 Op.Ty->castAs<ComplexType>()->getElementType()); in EmitComplexBinOpLibCall()
771 Op.Ty->castAs<ComplexType>()->getElementType()); in EmitComplexBinOpLibCall()
783 4, Op.Ty->castAs<ComplexType>()->getElementType()); in EmitComplexBinOpLibCall()
791 CGCallee Callee = CGCallee::forDirect(Func, FQTy->getAs<FunctionProtoType>()); in EmitComplexBinOpLibCall()
795 Call->setCallingConv(CGF.CGM.getRuntimeCC()); in EmitComplexBinOpLibCall()
802 switch (Ty->getTypeID()) { in getComplexMultiplyLibCallName()
827 if (Op.LHS.first->getType()->isFloatingPointTy()) { in EmitBinMul()
829 // (a + ib) * (c + id) = (a * c - b * d) + i(a * d + b * c) in EmitBinMul()
838 // to carefully re-compute the correct infinity representation if in EmitBinMul()
841 // This is good, because the libcall re-computes the core multiplication in EmitBinMul()
842 // exactly the same as we do here and re-tests for NaNs in order to be in EmitBinMul()
867 llvm::BasicBlock *OrigBB = Branch->getParent(); in EmitBinMul()
871 Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight); in EmitBinMul()
878 Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight); in EmitBinMul()
884 getComplexMultiplyLibCallName(Op.LHS.first->getType()), Op); in EmitBinMul()
887 // Finally continue execution by phi-ing together the different in EmitBinMul()
890 llvm::PHINode *RealPHI = Builder.CreatePHI(ResR->getType(), 3, "real_mul_phi"); in EmitBinMul()
891 RealPHI->addIncoming(ResR, OrigBB); in EmitBinMul()
892 RealPHI->addIncoming(ResR, INaNBB); in EmitBinMul()
893 RealPHI->addIncoming(LibCallR, LibCallBB); in EmitBinMul()
894 llvm::PHINode *ImagPHI = Builder.CreatePHI(ResI->getType(), 3, "imag_mul_phi"); in EmitBinMul()
895 ImagPHI->addIncoming(ResI, OrigBB); in EmitBinMul()
896 ImagPHI->addIncoming(ResI, INaNBB); in EmitBinMul()
897 ImagPHI->addIncoming(LibCallI, LibCallBB); in EmitBinMul()
929 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) in EmitAlgebraicDiv()
942 llvm::Value *BCmAD = Builder.CreateFSub(BC, AD); // bc-ad in EmitAlgebraicDiv()
949 // EmitFAbs - Emit a call to @llvm.fabs.
952 CGF.CGM.getIntrinsic(llvm::Intrinsic::fabs, Value->getType()); in EmitllvmFAbs()
957 // EmitRangeReductionDiv - Implements Smith's algorithm for complex division.
966 // (a + ib) / (c + id) = (e + if) in EmitRangeReductionDiv()
983 // e = (a + br)/tmp in EmitRangeReductionDiv()
984 // f = (b - ar)/tmp in EmitRangeReductionDiv()
985 llvm::Value *DdC = Builder.CreateFDiv(RHSi, RHSr); // r=d/c in EmitRangeReductionDiv() local
987 llvm::Value *RD = Builder.CreateFMul(DdC, RHSi); // rd in EmitRangeReductionDiv()
990 llvm::Value *T3 = Builder.CreateFMul(LHSi, DdC); // br in EmitRangeReductionDiv()
994 llvm::Value *T5 = Builder.CreateFMul(LHSr, DdC); // ar in EmitRangeReductionDiv()
995 llvm::Value *T6 = Builder.CreateFSub(LHSi, T5); // b-ar in EmitRangeReductionDiv()
996 llvm::Value *DSTTi = Builder.CreateFDiv(T6, CpRD); // (b-ar)/tmp in EmitRangeReductionDiv()
1003 // e = (ar + b)/tmp in EmitRangeReductionDiv()
1004 // f = (br - a)/tmp in EmitRangeReductionDiv()
1015 llvm::Value *T10 = Builder.CreateFSub(T9, LHSr); // br-a in EmitRangeReductionDiv()
1016 llvm::Value *DSTFi = Builder.CreateFDiv(T10, DpRC); // (br-a)/tmp in EmitRangeReductionDiv()
1021 llvm::PHINode *VALr = Builder.CreatePHI(DSTTr->getType(), 2); in EmitRangeReductionDiv()
1022 VALr->addIncoming(DSTTr, TrueBB); in EmitRangeReductionDiv()
1023 VALr->addIncoming(DSTFr, FalseBB); in EmitRangeReductionDiv()
1024 llvm::PHINode *VALi = Builder.CreatePHI(DSTTi->getType(), 2); in EmitRangeReductionDiv()
1025 VALi->addIncoming(DSTTi, TrueBB); in EmitRangeReductionDiv()
1026 VALi->addIncoming(DSTFi, FalseBB); in EmitRangeReductionDiv()
1036 if (LHSr->getType()->isFloatingPointTy()) { in EmitBinDiv()
1039 assert(LHSi && "Can have at most one non-complex operand!"); in EmitBinDiv()
1047 LHSi = llvm::Constant::getNullValue(RHSi->getType()); in EmitBinDiv()
1055 // '-ffast-math' is used in the command line but followed by an in EmitBinDiv()
1056 // '-fno-cx-limited-range' or '-fcomplex-arithmetic=full'. in EmitBinDiv()
1066 LibCallOp.LHS.second = llvm::Constant::getNullValue(LHSr->getType()); in EmitBinDiv()
1068 switch (LHSr->getType()->getTypeID()) { in EmitBinDiv()
1090 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) in EmitBinDiv()
1101 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad in EmitBinDiv()
1103 if (Op.Ty->castAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) { in EmitBinDiv()
1118 ConvertType(UnPromotionType->castAs<ComplexType>()->getElementType()); in EmitUnPromotedValue()
1131 ConvertType(PromotionType->castAs<ComplexType>()->getElementType()); in EmitPromotedValue()
1140 ComplexPairTy ComplexExprEmitter::EmitPromoted(const Expr *E, in EmitPromoted() argument
1142 E = E->IgnoreParens(); in EmitPromoted()
1143 if (auto BO = dyn_cast<BinaryOperator>(E)) { in EmitPromoted()
1144 switch (BO->getOpcode()) { in EmitPromoted()
1156 } else if (auto UO = dyn_cast<UnaryOperator>(E)) { in EmitPromoted()
1157 switch (UO->getOpcode()) { in EmitPromoted()
1166 auto result = Visit(const_cast<Expr *>(E)); in EmitPromoted()
1173 ComplexPairTy CodeGenFunction::EmitPromotedComplexExpr(const Expr *E, in EmitPromotedComplexExpr() argument
1175 return ComplexExprEmitter(*this).EmitPromoted(E, DstTy); in EmitPromotedComplexExpr()
1179 ComplexExprEmitter::EmitPromotedComplexOperand(const Expr *E, in EmitPromotedComplexOperand() argument
1181 if (E->getType()->isAnyComplexType()) { in EmitPromotedComplexOperand()
1183 return CGF.EmitPromotedComplexExpr(E, OverallPromotionType); in EmitPromotedComplexOperand()
1185 return Visit(const_cast<Expr *>(E)); in EmitPromotedComplexOperand()
1189 OverallPromotionType->castAs<ComplexType>()->getElementType(); in EmitPromotedComplexOperand()
1190 return ComplexPairTy(CGF.EmitPromotedScalarExpr(E, ComplexElementTy), in EmitPromotedComplexOperand()
1193 return ComplexPairTy(CGF.EmitScalarExpr(E), nullptr); in EmitPromotedComplexOperand()
1199 ComplexExprEmitter::EmitBinOps(const BinaryOperator *E, in EmitBinOps() argument
1205 Ops.LHS = EmitPromotedComplexOperand(E->getLHS(), PromotionType); in EmitBinOps()
1206 Ops.RHS = EmitPromotedComplexOperand(E->getRHS(), PromotionType); in EmitBinOps()
1210 Ops.Ty = E->getType(); in EmitBinOps()
1211 Ops.FPFeatures = E->getFPFeaturesInEffect(CGF.getLangOpts()); in EmitBinOps()
1217 EmitCompoundAssignLValue(const CompoundAssignOperator *E, in EmitCompoundAssignLValue() argument
1222 QualType LHSTy = E->getLHS()->getType(); in EmitCompoundAssignLValue()
1223 if (const AtomicType *AT = LHSTy->getAs<AtomicType>()) in EmitCompoundAssignLValue()
1224 LHSTy = AT->getValueType(); in EmitCompoundAssignLValue()
1227 OpInfo.FPFeatures = E->getFPFeaturesInEffect(CGF.getLangOpts()); in EmitCompoundAssignLValue()
1234 PromotionTypeCR = getPromotionType(E->getStoredFPFeaturesOrDefault(), in EmitCompoundAssignLValue()
1235 E->getComputationResultType()); in EmitCompoundAssignLValue()
1237 PromotionTypeCR = E->getComputationResultType(); in EmitCompoundAssignLValue()
1240 OpInfo.Ty->castAs<ComplexType>()->getElementType(); in EmitCompoundAssignLValue()
1242 E->getStoredFPFeaturesOrDefault(), E->getRHS()->getType()); in EmitCompoundAssignLValue()
1245 if (E->getRHS()->getType()->isRealFloatingType()) { in EmitCompoundAssignLValue()
1248 CGF.EmitPromotedScalarExpr(E->getRHS(), PromotionTypeRHS), nullptr); in EmitCompoundAssignLValue()
1251 E->getRHS()->getType())); in EmitCompoundAssignLValue()
1253 OpInfo.RHS = ComplexPairTy(CGF.EmitScalarExpr(E->getRHS()), nullptr); in EmitCompoundAssignLValue()
1258 CGF.EmitPromotedComplexExpr(E->getRHS(), PromotionTypeRHS)); in EmitCompoundAssignLValue()
1261 E->getRHS()->getType())); in EmitCompoundAssignLValue()
1262 OpInfo.RHS = Visit(E->getRHS()); in EmitCompoundAssignLValue()
1266 LValue LHS = CGF.EmitLValue(E->getLHS()); in EmitCompoundAssignLValue()
1268 // Load from the l-value and convert it. in EmitCompoundAssignLValue()
1269 SourceLocation Loc = E->getExprLoc(); in EmitCompoundAssignLValue()
1271 E->getStoredFPFeaturesOrDefault(), E->getComputationLHSType()); in EmitCompoundAssignLValue()
1272 if (LHSTy->isAnyComplexType()) { in EmitCompoundAssignLValue()
1283 if (LHSTy->isRealFloatingType()) { in EmitCompoundAssignLValue()
1287 cast<ComplexType>(PromotionTypeLHS)->getElementType(); in EmitCompoundAssignLValue()
1304 ComplexPairTy Result = (this->*Func)(OpInfo); in EmitCompoundAssignLValue()
1307 if (LHSTy->isAnyComplexType()) { in EmitCompoundAssignLValue()
1324 EmitCompoundAssign(const CompoundAssignOperator *E, in EmitCompoundAssign() argument
1327 LValue LV = EmitCompoundAssignLValue(E, Func, Val); in EmitCompoundAssign()
1329 // The result of an assignment in C is the assigned r-value. in EmitCompoundAssign()
1333 // If the lvalue is non-volatile, return the computed value of the assignment. in EmitCompoundAssign()
1337 return EmitLoadOfLValue(LV, E->getExprLoc()); in EmitCompoundAssign()
1340 LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E, in EmitBinAssignLValue() argument
1342 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), in EmitBinAssignLValue()
1343 E->getRHS()->getType()) && in EmitBinAssignLValue()
1349 Val = Visit(E->getRHS()); in EmitBinAssignLValue()
1352 LValue LHS = CGF.EmitLValue(E->getLHS()); in EmitBinAssignLValue()
1360 ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { in VisitBinAssign() argument
1362 LValue LV = EmitBinAssignLValue(E, Val); in VisitBinAssign()
1364 // The result of an assignment in C is the assigned r-value. in VisitBinAssign()
1368 // If the lvalue is non-volatile, return the computed value of the assignment. in VisitBinAssign()
1372 return EmitLoadOfLValue(LV, E->getExprLoc()); in VisitBinAssign()
1375 ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { in VisitBinComma() argument
1376 CGF.EmitIgnoredExpr(E->getLHS()); in VisitBinComma()
1377 return Visit(E->getRHS()); in VisitBinComma()
1381 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { in VisitAbstractConditionalOperator() argument
1389 CodeGenFunction::OpaqueValueMapping binding(CGF, E); in VisitAbstractConditionalOperator()
1393 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock, in VisitAbstractConditionalOperator()
1394 CGF.getProfileCount(E)); in VisitAbstractConditionalOperator()
1399 CGF.incrementProfileCounter(E->getTrueExpr()); in VisitAbstractConditionalOperator()
1401 CGF.incrementProfileCounter(E); in VisitAbstractConditionalOperator()
1403 ComplexPairTy LHS = Visit(E->getTrueExpr()); in VisitAbstractConditionalOperator()
1411 CGF.incrementProfileCounter(E->getFalseExpr()); in VisitAbstractConditionalOperator()
1412 ComplexPairTy RHS = Visit(E->getFalseExpr()); in VisitAbstractConditionalOperator()
1416 CGF.incrementProfileCounter(E); in VisitAbstractConditionalOperator()
1420 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r"); in VisitAbstractConditionalOperator()
1421 RealPN->addIncoming(LHS.first, LHSBlock); in VisitAbstractConditionalOperator()
1422 RealPN->addIncoming(RHS.first, RHSBlock); in VisitAbstractConditionalOperator()
1425 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i"); in VisitAbstractConditionalOperator()
1426 ImagPN->addIncoming(LHS.second, LHSBlock); in VisitAbstractConditionalOperator()
1427 ImagPN->addIncoming(RHS.second, RHSBlock); in VisitAbstractConditionalOperator()
1432 ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { in VisitChooseExpr() argument
1433 return Visit(E->getChosenSubExpr()); in VisitChooseExpr()
1436 ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { in VisitInitListExpr() argument
1444 if (E->getNumInits() == 2) { in VisitInitListExpr()
1445 llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0)); in VisitInitListExpr()
1446 llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1)); in VisitInitListExpr()
1448 } else if (E->getNumInits() == 1) { in VisitInitListExpr()
1449 return Visit(E->getInit(0)); in VisitInitListExpr()
1453 assert(E->getNumInits() == 0 && "Unexpected number of inits"); in VisitInitListExpr()
1454 QualType Ty = E->getType()->castAs<ComplexType>()->getElementType(); in VisitInitListExpr()
1460 ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { in VisitVAArgExpr() argument
1462 RValue RV = CGF.EmitVAArg(E, ArgValue); in VisitVAArgExpr()
1465 CGF.ErrorUnsupported(E, "complex va_arg expression"); in VisitVAArgExpr()
1467 CGF.ConvertType(E->getType()->castAs<ComplexType>()->getElementType()); in VisitVAArgExpr()
1475 //===----------------------------------------------------------------------===//
1477 //===----------------------------------------------------------------------===//
1479 /// EmitComplexExpr - Emit the computation of the specified expression of
1481 ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal, in EmitComplexExpr() argument
1483 assert(E && getComplexType(E->getType()) && in EmitComplexExpr()
1487 .Visit(const_cast<Expr *>(E)); in EmitComplexExpr()
1490 void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest, in EmitComplexExprIntoLValue() argument
1492 assert(E && getComplexType(E->getType()) && in EmitComplexExprIntoLValue()
1495 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); in EmitComplexExprIntoLValue()
1499 /// EmitStoreOfComplex - Store a complex number into the specified l-value.
1505 /// EmitLoadOfComplex - Load a complex number from the specified address.
1511 LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) { in EmitComplexAssignmentLValue() argument
1512 assert(E->getOpcode() == BO_Assign); in EmitComplexAssignmentLValue()
1514 LValue LVal = ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val); in EmitComplexAssignmentLValue()
1517 E->getLHS()); in EmitComplexAssignmentLValue()
1536 EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) { in EmitComplexCompoundAssignmentLValue() argument
1537 CompoundFunc Op = getComplexOp(E->getOpcode()); in EmitComplexCompoundAssignmentLValue()
1539 return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); in EmitComplexCompoundAssignmentLValue()
1543 EmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E, in EmitScalarCompoundAssignWithComplex() argument
1545 CompoundFunc Op = getComplexOp(E->getOpcode()); in EmitScalarCompoundAssignWithComplex()
1547 LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); in EmitScalarCompoundAssignWithComplex()