Lines Matching defs:E
98 const Expr *E; // Entire expr, for error unsupported. May not be binop.
141 if (const auto *BinOp = dyn_cast<BinaryOperator>(E)) {
146 if (const auto *UnOp = dyn_cast<UnaryOperator>(E))
153 if (const auto *BinOp = dyn_cast<BinaryOperator>(E)) {
161 static bool MustVisitNullValue(const Expr *E) {
165 return E->getType()->isNullPtrType();
168 /// If \p E is a widened promoted integer, get its base (unpromoted) type.
170 const Expr *E) {
171 const Expr *Base = E->IgnoreImpCasts();
172 if (E == Base)
177 Ctx.getTypeSize(BaseTy) >= Ctx.getTypeSize(E->getType()))
183 /// Check if \p E is a widened promoted integer.
184 static bool IsWidenedIntegerOp(const ASTContext &Ctx, const Expr *E) {
185 return getUnwidenedIntegerType(Ctx, E).has_value();
190 assert((isa<UnaryOperator>(Op.E) || isa<BinaryOperator>(Op.E)) &&
199 if (const auto *UO = dyn_cast<UnaryOperator>(Op.E))
204 const auto *BO = cast<BinaryOperator>(Op.E);
224 unsigned PromotedSize = Ctx.getTypeSize(Op.E->getType());
253 LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); }
254 LValue EmitCheckedLValue(const Expr *E, CodeGenFunction::TypeCheckKind TCK) {
255 return CGF.EmitCheckedLValue(E, TCK);
265 void EmitLValueAlignmentAssumption(const Expr *E, Value *V) {
267 if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) {
288 if (const auto *TTy = E->getType()->getAs<TypedefType>())
296 CGF.emitAlignmentAssumption(V, E, AVAttr->getLocation(), AlignmentCI);
302 Value *EmitLoadOfLValue(const Expr *E) {
303 Value *V = EmitLoadOfLValue(EmitCheckedLValue(E, CodeGenFunction::TCK_Load),
304 E->getExprLoc());
306 EmitLValueAlignmentAssumption(E, V);
420 Value *Visit(Expr *E) {
421 ApplyDebugLocation DL(CGF, E);
422 return StmtVisitor<ScalarExprEmitter, Value*>::Visit(E);
431 Value *VisitConstantExpr(ConstantExpr *E) {
434 if (E->getType()->isVoidType())
437 if (Value *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E)) {
438 if (E->isGLValue())
440 Address(Result, CGF.convertTypeForLoadStore(E->getType()),
441 CGF.getContext().getTypeAlignInChars(E->getType())),
442 /*Volatile*/ false, E->getType(), E->getExprLoc());
445 return Visit(E->getSubExpr());
450 Value *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
451 return Visit(E->getReplacement());
462 Value *VisitUnaryCoawait(const UnaryOperator *E) {
463 return Visit(E->getSubExpr());
467 Value *VisitIntegerLiteral(const IntegerLiteral *E) {
468 return Builder.getInt(E->getValue());
470 Value *VisitFixedPointLiteral(const FixedPointLiteral *E) {
471 return Builder.getInt(E->getValue());
473 Value *VisitFloatingLiteral(const FloatingLiteral *E) {
474 return llvm::ConstantFP::get(VMContext, E->getValue());
476 Value *VisitCharacterLiteral(const CharacterLiteral *E) {
477 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
479 Value *VisitObjCBoolLiteralExpr(const ObjCBoolLiteralExpr *E) {
480 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
482 Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
483 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
485 Value *VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) {
486 if (E->getType()->isVoidType())
489 return EmitNullValue(E->getType());
491 Value *VisitGNUNullExpr(const GNUNullExpr *E) {
492 return EmitNullValue(E->getType());
494 Value *VisitOffsetOfExpr(OffsetOfExpr *E);
495 Value *VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E);
496 Value *VisitAddrLabelExpr(const AddrLabelExpr *E) {
497 llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel());
498 return Builder.CreateBitCast(V, ConvertType(E->getType()));
501 Value *VisitSizeOfPackExpr(SizeOfPackExpr *E) {
502 return llvm::ConstantInt::get(ConvertType(E->getType()),E->getPackLength());
505 Value *VisitPseudoObjectExpr(PseudoObjectExpr *E) {
506 return CGF.EmitPseudoObjectRValue(E).getScalarVal();
509 Value *VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E);
510 Value *VisitEmbedExpr(EmbedExpr *E);
512 Value *VisitOpaqueValueExpr(OpaqueValueExpr *E) {
513 if (E->isGLValue())
514 return EmitLoadOfLValue(CGF.getOrCreateOpaqueLValueMapping(E),
515 E->getExprLoc());
518 return CGF.getOrCreateOpaqueRValueMapping(E).getScalarVal();
522 Value *VisitDeclRefExpr(DeclRefExpr *E) {
523 if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E))
524 return CGF.emitScalarConstant(Constant, E);
525 return EmitLoadOfLValue(E);
528 Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
529 return CGF.EmitObjCSelectorExpr(E);
531 Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
532 return CGF.EmitObjCProtocolExpr(E);
534 Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
535 return EmitLoadOfLValue(E);
537 Value *VisitObjCMessageExpr(ObjCMessageExpr *E) {
538 if (E->getMethodDecl() &&
539 E->getMethodDecl()->getReturnType()->isReferenceType())
540 return EmitLoadOfLValue(E);
541 return CGF.EmitObjCMessageExpr(E).getScalarVal();
544 Value *VisitObjCIsaExpr(ObjCIsaExpr *E) {
545 LValue LV = CGF.EmitObjCIsaExpr(E);
546 Value *V = CGF.EmitLoadOfLValue(LV, E->getExprLoc()).getScalarVal();
550 Value *VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
551 VersionTuple Version = E->getVersion();
561 Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
562 Value *VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E);
563 Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E);
564 Value *VisitConvertVectorExpr(ConvertVectorExpr *E);
565 Value *VisitMemberExpr(MemberExpr *E);
566 Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); }
567 Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
573 return EmitLoadOfLValue(E);
576 Value *VisitInitListExpr(InitListExpr *E);
578 Value *VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
584 Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
585 return EmitNullValue(E->getType());
587 Value *VisitExplicitCastExpr(ExplicitCastExpr *E) {
588 CGF.CGM.EmitExplicitCastExprType(E, &CGF);
589 return VisitCastExpr(E);
591 Value *VisitCastExpr(CastExpr *E);
593 Value *VisitCallExpr(const CallExpr *E) {
594 if (E->getCallReturnType(CGF.getContext())->isReferenceType())
595 return EmitLoadOfLValue(E);
597 Value *V = CGF.EmitCallExpr(E).getScalarVal();
599 EmitLValueAlignmentAssumption(E, V);
603 Value *VisitStmtExpr(const StmtExpr *E);
606 Value *VisitUnaryPostDec(const UnaryOperator *E) {
607 LValue LV = EmitLValue(E->getSubExpr());
608 return EmitScalarPrePostIncDec(E, LV, false, false);
610 Value *VisitUnaryPostInc(const UnaryOperator *E) {
611 LValue LV = EmitLValue(E->getSubExpr());
612 return EmitScalarPrePostIncDec(E, LV, true, false);
614 Value *VisitUnaryPreDec(const UnaryOperator *E) {
615 LValue LV = EmitLValue(E->getSubExpr());
616 return EmitScalarPrePostIncDec(E, LV, false, true);
618 Value *VisitUnaryPreInc(const UnaryOperator *E) {
619 LValue LV = EmitLValue(E->getSubExpr());
620 return EmitScalarPrePostIncDec(E, LV, true, true);
623 llvm::Value *EmitIncDecConsiderOverflowBehavior(const UnaryOperator *E,
627 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
631 Value *VisitUnaryAddrOf(const UnaryOperator *E) {
632 if (isa<MemberPointerType>(E->getType())) // never sugared
633 return CGF.CGM.getMemberPointerConstant(E);
635 return EmitLValue(E->getSubExpr()).getPointer(CGF);
637 Value *VisitUnaryDeref(const UnaryOperator *E) {
638 if (E->getType()->isVoidType())
639 return Visit(E->getSubExpr()); // the actual value should be unused
640 return EmitLoadOfLValue(E);
643 Value *VisitUnaryPlus(const UnaryOperator *E,
645 Value *VisitPlus(const UnaryOperator *E, QualType PromotionType);
646 Value *VisitUnaryMinus(const UnaryOperator *E,
648 Value *VisitMinus(const UnaryOperator *E, QualType PromotionType);
650 Value *VisitUnaryNot (const UnaryOperator *E);
651 Value *VisitUnaryLNot (const UnaryOperator *E);
652 Value *VisitUnaryReal(const UnaryOperator *E,
654 Value *VisitReal(const UnaryOperator *E, QualType PromotionType);
655 Value *VisitUnaryImag(const UnaryOperator *E,
657 Value *VisitImag(const UnaryOperator *E, QualType PromotionType);
658 Value *VisitUnaryExtension(const UnaryOperator *E) {
659 return Visit(E->getSubExpr());
663 Value *VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E) {
664 return EmitLoadOfLValue(E);
686 Value *VisitExprWithCleanups(ExprWithCleanups *E);
687 Value *VisitCXXNewExpr(const CXXNewExpr *E) {
688 return CGF.EmitCXXNewExpr(E);
690 Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) {
691 CGF.EmitCXXDeleteExpr(E);
695 Value *VisitTypeTraitExpr(const TypeTraitExpr *E) {
696 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
699 Value *VisitConceptSpecializationExpr(const ConceptSpecializationExpr *E) {
700 return Builder.getInt1(E->isSatisfied());
703 Value *VisitRequiresExpr(const RequiresExpr *E) {
704 return Builder.getInt1(E->isSatisfied());
707 Value *VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) {
708 return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue());
711 Value *VisitExpressionTraitExpr(const ExpressionTraitExpr *E) {
712 return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue());
715 Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) {
721 CGF.EmitScalarExpr(E->getBase());
725 Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) {
726 return EmitNullValue(E->getType());
729 Value *VisitCXXThrowExpr(const CXXThrowExpr *E) {
730 CGF.EmitCXXThrowExpr(E);
734 Value *VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) {
735 return Builder.getInt1(E->getValue());
761 auto *BO = cast<BinaryOperator>(Ops.E);
821 BinOpInfo EmitBinOps(const BinaryOperator *E,
826 Value *EmitPromoted(const Expr *E, QualType PromotionType);
828 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E,
832 Value *EmitCompoundAssign(const CompoundAssignOperator *E,
856 Value *VisitBin##OP(const BinaryOperator *E) { \
857 QualType promotionTy = getPromotionType(E->getType()); \
858 auto result = Emit##OP(EmitBinOps(E, promotionTy)); \
860 result = EmitUnPromotedValue(result, E->getType()); \
863 Value *VisitBin##OP##Assign(const CompoundAssignOperator *E) { \
864 return EmitCompoundAssign(E, &ScalarExprEmitter::Emit##OP); \
879 Value *EmitCompare(const BinaryOperator *E, llvm::CmpInst::Predicate UICmpOpc,
883 Value *VisitBin##CODE(const BinaryOperator *E) { \
884 return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \
894 Value *VisitBinAssign (const BinaryOperator *E);
896 Value *VisitBinLAnd (const BinaryOperator *E);
897 Value *VisitBinLOr (const BinaryOperator *E);
898 Value *VisitBinComma (const BinaryOperator *E);
900 Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); }
901 Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); }
903 Value *VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) {
904 return Visit(E->getSemanticForm());
912 Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) {
913 return CGF.EmitObjCStringLiteral(E);
915 Value *VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
916 return CGF.EmitObjCBoxedExpr(E);
918 Value *VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
919 return CGF.EmitObjCArrayLiteral(E);
921 Value *VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
922 return CGF.EmitObjCDictionaryLiteral(E);
926 Value *VisitPackIndexingExpr(PackIndexingExpr *E) {
927 return Visit(E->getSelectedExpr());
1741 StaticData.push_back(CGF.EmitCheckSourceLocation(Info.E->getExprLoc()));
1742 const UnaryOperator *UO = dyn_cast<UnaryOperator>(Info.E);
1751 const BinaryOperator *BO = cast<BinaryOperator>(Info.E);
1781 Value *ScalarExprEmitter::VisitExpr(Expr *E) {
1782 CGF.ErrorUnsupported(E, "scalar expression");
1783 if (E->getType()->isVoidType())
1785 return llvm::UndefValue::get(CGF.ConvertType(E->getType()));
1789 ScalarExprEmitter::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
1794 E->ComputeName(Context), "__usn_str", AddrSpace);
1796 llvm::Type *ExprTy = ConvertType(E->getType());
1801 Value *ScalarExprEmitter::VisitEmbedExpr(EmbedExpr *E) {
1802 assert(E->getDataElementCount() == 1);
1803 auto It = E->begin();
1807 Value *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1809 if (E->getNumSubExprs() == 2) {
1810 Value *LHS = CGF.EmitScalarExpr(E->getExpr(0));
1811 Value *RHS = CGF.EmitScalarExpr(E->getExpr(1));
1845 Value* V1 = CGF.EmitScalarExpr(E->getExpr(0));
1846 Value* V2 = CGF.EmitScalarExpr(E->getExpr(1));
1849 for (unsigned i = 2; i < E->getNumSubExprs(); ++i) {
1850 llvm::APSInt Idx = E->getShuffleMaskIdx(CGF.getContext(), i-2);
1861 Value *ScalarExprEmitter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1862 QualType SrcType = E->getSrcExpr()->getType(),
1863 DstType = E->getType();
1865 Value *Src = CGF.EmitScalarExpr(E->getSrcExpr());
1935 Value *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) {
1936 if (CodeGenFunction::ConstantEmission Constant = CGF.tryEmitAsConstant(E)) {
1937 CGF.EmitIgnoredExpr(E->getBase());
1938 return CGF.emitScalarConstant(Constant, E);
1941 if (E->EvaluateAsInt(Result, CGF.getContext(), Expr::SE_AllowSideEffects)) {
1943 CGF.EmitIgnoredExpr(E->getBase());
1948 llvm::Value *Result = EmitLoadOfLValue(E);
1959 QualType Ty = E->getBase()->getType();
1960 if (!E->isArrow())
1970 Value *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
1977 if (!E->getBase()->getType()->isVectorType() &&
1978 !E->getBase()->getType()->isSveVLSBuiltinType())
1979 return EmitLoadOfLValue(E);
1983 Value *Base = Visit(E->getBase());
1984 Value *Idx = Visit(E->getIdx());
1985 QualType IdxTy = E->getIdx()->getType();
1988 CGF.EmitBoundsCheck(E, E->getBase(), Idx, IdxTy, /*Accessed*/true);
1993 Value *ScalarExprEmitter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
1998 Value *RowIdx = Visit(E->getRowIdx());
1999 Value *ColumnIdx = Visit(E->getColumnIdx());
2001 const auto *MatrixTy = E->getBase()->getType()->castAs<ConstantMatrixType>();
2008 Value *Matrix = Visit(E->getBase());
2028 Value *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) {
2032 unsigned NumInitElements = E->getNumInits();
2034 if (E->hadArrayRangeDesignator())
2035 CGF.ErrorUnsupported(E, "GNU array range designator extension");
2038 dyn_cast<llvm::VectorType>(ConvertType(E->getType()));
2043 return EmitNullValue(E->getType());
2046 return Visit(E->getInit(0));
2052 return EmitNullValue(E->getType());
2056 Expr *InitVector = E->getInit(0);
2059 if (InitVector->getType() == E->getType())
2077 Expr *IE = E->getInit(i);
2200 const Expr *E = CE->getSubExpr();
2205 if (isa<CXXThisExpr>(E->IgnoreParens())) {
2223 Expr *E = CE->getSubExpr();
2242 Address Addr = EmitLValue(E).getAddress();
2249 LValue SourceLVal = CGF.EmitLValue(E);
2261 Value *Src = Visit(const_cast<Expr*>(E));
2275 E->getType()->castAs<PointerType>()->getPointeeType()),
2283 const QualType SrcType = E->getType();
2303 !isa<CastExpr>(E)) {
2370 LValue LV = CGF.MakeAddrLValue(Addr, E->getType());
2379 return CGF.authPointerToPointerCast(Result, E->getType(), DestTy);
2383 if (E->EvaluateAsRValue(Result, CGF.getContext()) &&
2385 // If E has side effect, it is emitted even if its final result is a
2387 // eliminate the useless instructions emitted during translating E.
2389 Visit(E);
2396 CGF, Visit(E), E->getType()->getPointeeType().getAddressSpace(),
2402 return Visit(const_cast<Expr*>(E));
2406 : Visit(const_cast<Expr *>(E));
2413 Address Base = CGF.EmitPointerWithAlignment(E);
2442 Address V = CGF.EmitPointerWithAlignment(E);
2448 return CGF.getAsNaturalPointerTo(CGF.EmitArrayToPointerDecay(E),
2451 return EmitLValue(E).getPointer(CGF);
2454 if (MustVisitNullValue(E))
2455 CGF.EmitIgnoredExpr(E);
2461 if (MustVisitNullValue(E))
2462 CGF.EmitIgnoredExpr(E);
2471 Value *Src = Visit(E);
2483 return CGF.EmitARCRetainScalarExpr(E);
2485 return CGF.EmitObjCConsumeObject(E->getType(), Visit(E));
2487 return CGF.EmitARCReclaimReturnedObject(E, /*allowUnsafe*/ Ignored);
2489 return CGF.EmitARCExtendBlockObject(E);
2492 return CGF.EmitBlockCopyAndAutorelease(Visit(E), E->getType());
2506 assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy));
2507 assert(E->isGLValue() && "lvalue-to-rvalue applied to r-value!");
2508 return Visit(const_cast<Expr*>(E));
2511 Value *Src = Visit(const_cast<Expr*>(E));
2517 bool InputSigned = E->getType()->isSignedIntegerOrEnumerationType();
2530 IntToPtr = CGF.authPointerToPointerCast(IntToPtr, E->getType(), DestTy);
2535 auto *PtrExpr = Visit(E);
2538 const QualType SrcType = E->getType();
2546 PtrExpr = CGF.authPointerToPointerCast(PtrExpr, E->getType(), DestTy);
2550 CGF.EmitIgnoredExpr(E);
2554 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2559 Value *Elt = Visit(const_cast<Expr *>(E));
2567 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2571 assert(E->getType()->isFixedPointType() &&
2574 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2578 assert(E->getType()->isFixedPointType() &&
2581 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2585 assert(E->getType()->isIntegerType() &&
2589 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2593 if (E->getType()->isExtVectorType() && DestTy->isExtVectorType()) {
2594 QualType SrcElTy = E->getType()->castAs<VectorType>()->getElementType();
2595 return Builder.CreateIntCast(Visit(E), ConvertType(DestTy),
2604 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2608 if (E->getType()->isVectorType() && DestTy->isVectorType()) {
2610 QualType SrcElTy = E->getType()->castAs<VectorType>()->getElementType();
2612 return Builder.CreateSIToFP(Visit(E), ConvertType(DestTy), "conv");
2613 return Builder.CreateUIToFP(Visit(E), ConvertType(DestTy), "conv");
2616 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2620 if (E->getType()->isVectorType() && DestTy->isVectorType()) {
2624 return Builder.CreateFPToSI(Visit(E), ConvertType(DestTy), "conv");
2625 return Builder.CreateFPToUI(Visit(E), ConvertType(DestTy), "conv");
2628 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2632 if (E->getType()->isVectorType() && DestTy->isVectorType()) {
2634 QualType SrcElTy = E->getType()->castAs<VectorType>()->getElementType();
2638 return Builder.CreateFPTrunc(Visit(E), ConvertType(DestTy), "conv");
2639 return Builder.CreateFPExt(Visit(E), ConvertType(DestTy), "conv");
2642 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2648 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2654 return EmitScalarConversion(Visit(E), E->getType(), DestTy,
2658 return EmitIntToBoolConversion(Visit(E));
2660 return EmitPointerToBoolConversion(Visit(E), E->getType());
2663 return EmitFloatToBoolConversion(Visit(E));
2666 llvm::Value *MemPtr = Visit(E);
2667 const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>();
2673 return CGF.EmitComplexExpr(E, false, true).first;
2677 CodeGenFunction::ComplexPairTy V = CGF.EmitComplexExpr(E);
2680 return EmitComplexToScalarConversion(V, E->getType(), DestTy,
2692 return CGF.CGM.createOpenCLIntToSamplerConversion(E, CGF);
2696 Value *Vec = Visit(const_cast<Expr *>(E));
2710 Value *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) {
2712 Address RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(),
2713 !E->getType()->isVoidType());
2716 return CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(RetAlloca, E->getType()),
2717 E->getExprLoc());
2720 Value *ScalarExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
2722 Value *V = Visit(E->getSubExpr());
2733 static BinOpInfo createBinOpInfoFromIncDec(const UnaryOperator *E,
2739 BinOp.Ty = E->getType();
2742 BinOp.E = E;
2747 const UnaryOperator *E, llvm::Value *InVal, bool IsInc) {
2761 if (!E->canOverflow())
2764 E, InVal, IsInc, E->getFPFeaturesInEffect(CGF.getLangOpts())));
2774 const UnaryOperator *E;
2778 const UnaryOperator *E)
2779 : CGF(CGF), E(E) {}
2783 CGF, E->getSubExpr());
2789 ScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
2791 OMPLastprivateConditionalUpdateRAII OMPRegion(CGF, E);
2792 QualType type = E->getSubExpr()->getType();
2797 QualType SrcType = E->getType();
2853 value = EmitLoadOfLValue(LV, E->getExprLoc());
2865 value = EmitLoadOfLValue(LV, E->getExprLoc());
2919 value = EmitScalarConversion(value, type, promotedType, E->getExprLoc());
2933 value = EmitScalarConversion(value, promotedType, type, E->getExprLoc(),
2939 } else if (E->canOverflow() && type->isSignedIntegerOrEnumerationType()) {
2940 value = EmitIncDecConsiderOverflowBehavior(E, value, isInc);
2941 } else if (E->canOverflow() && type->isUnsignedIntegerType() &&
2944 E, value, isInc, E->getFPFeaturesInEffect(CGF.getLangOpts())));
2965 E->getExprLoc(), "vla.inc");
2977 E->getExprLoc(), "incdec.funcptr");
2988 E->getExprLoc(), "incdec.ptr");
3008 CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, E);
3068 Info.E = E;
3069 Info.Ty = E->getType();
3101 E->getExprLoc(), "incdec.objptr");
3109 LV, RValue::get(atomicPHI), RValue::get(value), E->getExprLoc());
3122 CGF.EmitBitfieldConversionCheck(Src, SrcType, value, E->getType(),
3123 LV.getBitFieldInfo(), E->getExprLoc());
3133 Value *ScalarExprEmitter::VisitUnaryPlus(const UnaryOperator *E,
3136 ? getPromotionType(E->getSubExpr()->getType())
3138 Value *result = VisitPlus(E, promotionTy);
3140 result = EmitUnPromotedValue(result, E->getType());
3144 Value *ScalarExprEmitter::VisitPlus(const UnaryOperator *E,
3149 return CGF.EmitPromotedScalarExpr(E->getSubExpr(), PromotionType);
3150 return Visit(E->getSubExpr());
3153 Value *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E,
3156 ? getPromotionType(E->getSubExpr()->getType())
3158 Value *result = VisitMinus(E, promotionTy);
3160 result = EmitUnPromotedValue(result, E->getType());
3164 Value *ScalarExprEmitter::VisitMinus(const UnaryOperator *E,
3169 Op = CGF.EmitPromotedScalarExpr(E->getSubExpr(), PromotionType);
3171 Op = Visit(E->getSubExpr());
3181 BinOp.Ty = E->getType();
3183 BinOp.FPFeatures = E->getFPFeaturesInEffect(CGF.getLangOpts());
3184 BinOp.E = E;
3188 Value *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
3190 Value *Op = Visit(E->getSubExpr());
3194 Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) {
3196 if (E->getType()->isVectorType() &&
3197 E->getType()->castAs<VectorType>()->getVectorKind() ==
3199 Value *Oper = Visit(E->getSubExpr());
3204 CGF, E->getFPFeaturesInEffect(CGF.getLangOpts()));
3208 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
3212 Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr());
3220 return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext");
3223 Value *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) {
3226 if (E->EvaluateAsInt(EVResult, CGF.getContext())) {
3232 unsigned n = E->getNumComponents();
3233 llvm::Type* ResultType = ConvertType(E->getType());
3235 QualType CurrentType = E->getTypeSourceInfo()->getType();
3237 OffsetOfNode ON = E->getComponent(i);
3242 Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex());
3291 CGF.ErrorUnsupported(E, "virtual base in offsetof");
3318 const UnaryExprOrTypeTraitExpr *E) {
3319 QualType TypeToSize = E->getTypeOfArgument();
3320 if (auto Kind = E->getKind();
3324 if (E->isArgumentType()) {
3330 CGF.EmitIgnoredExpr(E->getArgumentExpr());
3343 } else if (E->getKind() == UETT_OpenMPRequiredSimdAlign) {
3347 E->getTypeOfArgument()->getPointeeType()))
3350 } else if (E->getKind() == UETT_VectorElements) {
3351 auto *VecTy = cast<llvm::VectorType>(ConvertType(E->getTypeOfArgument()));
3357 return Builder.getInt(E->EvaluateKnownConstInt(CGF.getContext()));
3360 Value *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E,
3363 ? getPromotionType(E->getSubExpr()->getType())
3365 Value *result = VisitReal(E, promotionTy);
3367 result = EmitUnPromotedValue(result, E->getType());
3371 Value *ScalarExprEmitter::VisitReal(const UnaryOperator *E,
3373 Expr *Op = E->getSubExpr();
3376 // Note that we have to ask E because Op might be an l-value that
3378 if (E->isGLValue()) {
3386 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E), E->getExprLoc())
3399 Value *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E,
3402 ? getPromotionType(E->getSubExpr()->getType())
3404 Value *result = VisitImag(E, promotionTy);
3406 result = EmitUnPromotedValue(result, E->getType());
3410 Value *ScalarExprEmitter::VisitImag(const UnaryOperator *E,
3412 Expr *Op = E->getSubExpr();
3415 // Note that we have to ask E because Op might be an l-value that
3425 return CGF.EmitLoadOfLValue(CGF.EmitLValue(E), E->getExprLoc())
3443 return llvm::Constant::getNullValue(ConvertType(E->getType()));
3460 Value *ScalarExprEmitter::EmitPromoted(const Expr *E, QualType PromotionType) {
3461 E = E->IgnoreParens();
3462 if (auto BO = dyn_cast<BinaryOperator>(E)) {
3475 } else if (auto UO = dyn_cast<UnaryOperator>(E)) {
3489 auto result = Visit(const_cast<Expr *>(E));
3494 return EmitUnPromotedValue(result, E->getType());
3499 BinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E,
3503 Result.LHS = CGF.EmitPromotedScalarExpr(E->getLHS(), PromotionType);
3504 Result.RHS = CGF.EmitPromotedScalarExpr(E->getRHS(), PromotionType);
3508 Result.Ty = E->getType();
3509 Result.Opcode = E->getOpcode();
3510 Result.FPFeatures = E->getFPFeaturesInEffect(CGF.getLangOpts());
3511 Result.E = E;
3516 const CompoundAssignOperator *E,
3519 QualType LHSTy = E->getLHS()->getType();
3522 if (E->getComputationResultType()->isAnyComplexType())
3523 return CGF.EmitScalarCompoundAssignWithComplex(E, Result);
3529 PromotionTypeCR = getPromotionType(E->getComputationResultType());
3531 PromotionTypeCR = E->getComputationResultType();
3532 QualType PromotionTypeLHS = getPromotionType(E->getComputationLHSType());
3533 QualType PromotionTypeRHS = getPromotionType(E->getRHS()->getType());
3535 OpInfo.RHS = CGF.EmitPromotedScalarExpr(E->getRHS(), PromotionTypeRHS);
3537 OpInfo.RHS = Visit(E->getRHS());
3539 OpInfo.Opcode = E->getOpcode();
3540 OpInfo.FPFeatures = E->getFPFeaturesInEffect(CGF.getLangOpts());
3541 OpInfo.E = E;
3543 LValue LHSLV = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
3587 EmitScalarConversion(OpInfo.RHS, E->getRHS()->getType(), LHSTy,
3588 E->getExprLoc()),
3604 OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->getExprLoc());
3613 OpInfo.LHS = EmitLoadOfLValue(LHSLV, E->getExprLoc());
3616 SourceLocation Loc = E->getExprLoc();
3619 E->getExprLoc());
3622 E->getComputationLHSType(), Loc);
3643 LHSLV, RValue::get(atomicPHI), RValue::get(Result), E->getExprLoc());
3658 QualType SrcType = E->getRHS()->getType();
3659 QualType DstType = E->getLHS()->getType();
3662 LHSLV.getBitFieldInfo(), E->getExprLoc());
3668 E->getLHS());
3672 Value *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E,
3676 LValue LHS = EmitCompoundAssignLValue(E, Func, RHS);
3691 return EmitLoadOfLValue(LHS, E->getExprLoc());
3703 const auto *BO = cast<BinaryOperator>(Ops.E);
3748 auto *BO = cast<BinaryOperator>(Ops.E);
3906 const BinaryOperator *expr = cast<BinaryOperator>(op.E);
3960 CGF.EmitBoundsCheck(op.E, pointerOperand, index, indexOperand->getType(),
3996 elemTy, pointer, index, isSigned, isSubtraction, op.E->getExprLoc(),
4015 elemTy, pointer, index, isSigned, isSubtraction, op.E->getExprLoc(),
4204 if (const auto *BinOp = dyn_cast<BinaryOperator>(op.E)) {
4215 } else if (const auto *UnOp = dyn_cast<UnaryOperator>(op.E)) {
4363 const BinaryOperator *expr = cast<BinaryOperator>(op.E);
4597 Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,
4604 QualType LHSTy = E->getLHS()->getType();
4605 QualType RHSTy = E->getRHS()->getType();
4607 assert(E->getOpcode() == BO_EQ ||
4608 E->getOpcode() == BO_NE);
4609 Value *LHS = CGF.EmitScalarExpr(E->getLHS());
4610 Value *RHS = CGF.EmitScalarExpr(E->getRHS());
4612 CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE);
4614 BinOpInfo BOInfo = EmitBinOps(E);
4620 if (LHSTy->isVectorType() && !E->getType()->isVectorType()) {
4633 switch(E->getOpcode()) {
4680 // The result type of intrinsic may not be same as E->getType().
4681 // If E->getType() is not BoolTy, EmitScalarConversion will do the
4682 // conversion work. If E->getType() is BoolTy, EmitScalarConversion will
4687 E->getType() == CGF.getContext().BoolTy)
4689 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType(),
4690 E->getExprLoc());
4728 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
4735 LHS = CGF.EmitComplexExpr(E->getLHS());
4738 LHS.first = Visit(E->getLHS());
4743 RHS = CGF.EmitComplexExpr(E->getRHS());
4749 RHS.first = Visit(E->getRHS());
4768 if (E->getOpcode() == BO_EQ) {
4771 assert(E->getOpcode() == BO_NE &&
4777 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType(),
4778 E->getExprLoc());
4782 const BinaryOperator *E, Value **Previous, QualType *SrcType) {
4785 if (auto *ICE = dyn_cast<ImplicitCastExpr>(E->getRHS())) {
4791 // integer sanitizer checks as E refers to bitfield.
4796 return EmitScalarExpr(E->getRHS());
4799 Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) {
4805 switch (E->getLHS()->getType().getObjCLifetime()) {
4807 std::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore);
4811 std::tie(LHS, RHS) = CGF.EmitARCStoreAutoreleasing(E);
4815 std::tie(LHS, RHS) = CGF.EmitARCStoreUnsafeUnretained(E, Ignore);
4819 RHS = Visit(E->getRHS());
4820 LHS = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
4828 QualType SrcType = E->getRHS()->getType();
4832 if (E->getLHS()->refersToBitField())
4833 RHS = CGF.EmitWithOriginalRHSBitfieldAssignment(E, &Previous, &SrcType);
4835 RHS = Visit(E->getRHS());
4837 LHS = EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
4848 QualType DstType = E->getLHS()->getType();
4850 LHS.getBitFieldInfo(), E->getExprLoc());
4852 CGF.EmitNullabilityCheck(LHS, RHS, E->getExprLoc());
4870 return EmitLoadOfLValue(LHS, E->getExprLoc());
4873 Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
4875 if (E->getType()->isVectorType()) {
4876 CGF.incrementProfileCounter(E);
4878 Value *LHS = Visit(E->getLHS());
4879 Value *RHS = Visit(E->getRHS());
4883 CGF, E->getFPFeaturesInEffect(CGF.getLangOpts()));
4891 return Builder.CreateSExt(And, ConvertType(E->getType()), "sext");
4895 llvm::Type *ResTy = ConvertType(E->getType());
4900 if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
4902 CGF.incrementProfileCounter(E);
4906 CGF.maybeResetMCDCCondBitmap(E);
4908 CGF.MCDCLogOpStack.push_back(E);
4910 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
4917 CodeGenFunction::isInstrumentedCondition(E->getRHS())) {
4918 CGF.maybeUpdateMCDCCondBitmap(E->getRHS(), RHSCond);
4923 CGF.incrementProfileCounter(E->getRHS());
4931 CGF.maybeUpdateMCDCTestVectorBitmap(E);
4938 if (!CGF.ContainsLabel(E->getRHS()))
4944 CGF.maybeResetMCDCCondBitmap(E);
4946 CGF.MCDCLogOpStack.push_back(E);
4954 CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock,
4955 CGF.getProfileCount(E->getRHS()));
4968 CGF.incrementProfileCounter(E);
4969 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
4979 CodeGenFunction::isInstrumentedCondition(E->getRHS())) {
4980 CGF.maybeUpdateMCDCCondBitmap(E->getRHS(), RHSCond);
4984 CGF.incrementProfileCounter(E->getRHS());
5001 CGF.maybeUpdateMCDCTestVectorBitmap(E);
5013 Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
5015 if (E->getType()->isVectorType()) {
5016 CGF.incrementProfileCounter(E);
5018 Value *LHS = Visit(E->getLHS());
5019 Value *RHS = Visit(E->getRHS());
5023 CGF, E->getFPFeaturesInEffect(CGF.getLangOpts()));
5031 return Builder.CreateSExt(Or, ConvertType(E->getType()), "sext");
5035 llvm::Type *ResTy = ConvertType(E->getType());
5040 if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) {
5042 CGF.incrementProfileCounter(E);
5046 CGF.maybeResetMCDCCondBitmap(E);
5048 CGF.MCDCLogOpStack.push_back(E);
5050 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
5057 CodeGenFunction::isInstrumentedCondition(E->getRHS())) {
5058 CGF.maybeUpdateMCDCCondBitmap(E->getRHS(), RHSCond);
5063 CGF.incrementProfileCounter(E->getRHS());
5071 CGF.maybeUpdateMCDCTestVectorBitmap(E);
5078 if (!CGF.ContainsLabel(E->getRHS()))
5084 CGF.maybeResetMCDCCondBitmap(E);
5086 CGF.MCDCLogOpStack.push_back(E);
5094 CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock,
5096 CGF.getProfileCount(E->getRHS()));
5111 CGF.incrementProfileCounter(E);
5112 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
5123 CodeGenFunction::isInstrumentedCondition(E->getRHS())) {
5124 CGF.maybeUpdateMCDCCondBitmap(E->getRHS(), RHSCond);
5128 CGF.incrementProfileCounter(E->getRHS());
5141 CGF.maybeUpdateMCDCTestVectorBitmap(E);
5147 Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) {
5148 CGF.EmitIgnoredExpr(E->getLHS());
5150 return Visit(E->getRHS());
5161 static bool isCheapEnoughToEvaluateUnconditionally(const Expr *E,
5164 return E->IgnoreParens()->isEvaluatable(CGF.getContext());
5176 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
5180 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
5182 Expr *condExpr = E->getCond();
5183 Expr *lhsExpr = E->getTrueExpr();
5184 Expr *rhsExpr = E->getFalseExpr();
5200 CGF.incrementProfileCounter(E);
5207 if (!Result && !E->getType()->isVoidType())
5208 Result = llvm::UndefValue::get(CGF.ConvertType(E->getType()));
5218 CGF.incrementProfileCounter(E);
5258 CGF.incrementProfileCounter(E);
5283 CGF.incrementProfileCounter(E);
5285 CGF.incrementProfileCounter(E, StepV);
5320 CGF.incrementProfileCounter(E);
5361 CGF.incrementProfileCounter(E);
5366 Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) {
5367 return Visit(E->getChosenSubExpr());
5439 Value *ScalarExprEmitter::VisitAsTypeExpr(AsTypeExpr *E) {
5440 Value *Src = CGF.EmitScalarExpr(E->getSrcExpr());
5441 llvm::Type *DstTy = ConvertType(E->getType());
5454 if (E->getType()->isExtVectorBoolType())
5486 Value *ScalarExprEmitter::VisitAtomicExpr(AtomicExpr *E) {
5487 return CGF.EmitAtomicExpr(E).getScalarVal();
5496 Value *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) {
5497 assert(E && hasScalarEvaluationKind(E->getType()) &&
5501 .Visit(const_cast<Expr *>(E));
5528 CodeGenFunction::EmitPromotedScalarExpr(const Expr *E,
5531 return ScalarExprEmitter(*this).EmitPromoted(E, PromotionType);
5533 return ScalarExprEmitter(*this).Visit(const_cast<Expr *>(E));
5538 EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV,
5540 return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre);
5543 LValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) {
5547 Expr *BaseExpr = E->getBase();
5558 Addr = Addr.withElementType(ConvertType(E->getType()));
5559 return MakeAddrLValue(Addr, E->getType());
5564 const CompoundAssignOperator *E) {
5567 switch (E->getOpcode()) {
5570 return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \