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