Lines Matching defs:E
79 ComplexPairTy EmitLoadOfLValue(const Expr *E) {
80 return EmitLoadOfLValue(CGF.EmitLValue(E), E->getExprLoc());
100 ComplexPairTy Visit(Expr *E) {
101 ApplyDebugLocation DL(CGF, E);
102 return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E);
110 ComplexPairTy VisitConstantExpr(ConstantExpr *E) {
111 if (llvm::Constant *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E))
114 return Visit(E->getSubExpr());
131 ComplexPairTy VisitUnaryCoawait(const UnaryOperator *E) {
132 return Visit(E->getSubExpr());
136 Expr *E) {
139 return EmitLoadOfLValue(Constant.getReferenceLValue(CGF, E),
140 E->getExprLoc());
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); }
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) {
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());
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,
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());
485 ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
486 CGF.ErrorUnsupported(E, "complex expression");
488 CGF.ConvertType(getComplexType(E->getType())->getElementType());
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());
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());
706 ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
710 ComplexPairTy Op = Visit(E->getSubExpr());
1140 ComplexPairTy ComplexExprEmitter::EmitPromoted(const Expr *E,
1142 E = E->IgnoreParens();
1143 if (auto BO = dyn_cast<BinaryOperator>(E)) {
1156 } else if (auto UO = dyn_cast<UnaryOperator>(E)) {
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));
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();
1227 OpInfo.FPFeatures = E->getFPFeaturesInEffect(CGF.getLangOpts());
1234 PromotionTypeCR = getPromotionType(E->getStoredFPFeaturesOrDefault(),
1235 E->getComputationResultType());
1237 PromotionTypeCR = E->getComputationResultType();
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());
1269 SourceLocation Loc = E->getExprLoc();
1271 E->getStoredFPFeaturesOrDefault(), E->getComputationLHSType());
1324 EmitCompoundAssign(const CompoundAssignOperator *E,
1327 LValue LV = EmitCompoundAssignLValue(E, Func, Val);
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);
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);
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());
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));
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);