Lines Matching defs:E
64 void withReturnValueSlot(const Expr *E,
79 void EmitAggLoadOfLValue(const Expr *E);
106 void Visit(Expr *E) {
107 ApplyDebugLocation DL(CGF, E);
108 StmtVisitor<AggExprEmitter>::Visit(E);
118 void VisitCoawaitExpr(CoawaitExpr *E) {
119 CGF.EmitCoawaitExpr(*E, Dest, IsResultUnused);
121 void VisitCoyieldExpr(CoyieldExpr *E) {
122 CGF.EmitCoyieldExpr(*E, Dest, IsResultUnused);
124 void VisitUnaryCoawait(UnaryOperator *E) { Visit(E->getSubExpr()); }
125 void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
126 void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
127 return Visit(E->getReplacement());
130 void VisitConstantExpr(ConstantExpr *E) {
131 EnsureDest(E->getType());
133 if (llvm::Value *Result = ConstantEmitter(CGF).tryEmitConstantExpr(E)) {
137 Dest.getPreferredSize(CGF.getContext(), E->getType())
139 E->getType().isVolatileQualified());
142 return Visit(E->getSubExpr());
146 void VisitDeclRefExpr(DeclRefExpr *E) { EmitAggLoadOfLValue(E); }
148 void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
149 void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }
150 void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
151 void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
152 EmitAggLoadOfLValue(E);
154 void VisitPredefinedExpr(const PredefinedExpr *E) {
155 EmitAggLoadOfLValue(E);
159 void VisitCastExpr(CastExpr *E);
160 void VisitCallExpr(const CallExpr *E);
161 void VisitStmtExpr(const StmtExpr *E);
164 void VisitBinAssign(const BinaryOperator *E);
165 void VisitBinComma(const BinaryOperator *E);
166 void VisitBinCmp(const BinaryOperator *E);
167 void VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) {
168 Visit(E->getSemanticForm());
171 void VisitObjCMessageExpr(ObjCMessageExpr *E);
172 void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
173 EmitAggLoadOfLValue(E);
176 void VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E);
179 void VisitInitListExpr(InitListExpr *E);
183 void VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E,
185 void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
186 void VisitNoInitExpr(NoInitExpr *E) { } // Do nothing.
195 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
196 void VisitCXXConstructExpr(const CXXConstructExpr *E);
197 void VisitCXXInheritedCtorInitExpr(const CXXInheritedCtorInitExpr *E);
198 void VisitLambdaExpr(LambdaExpr *E);
199 void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
200 void VisitExprWithCleanups(ExprWithCleanups *E);
201 void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
202 void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); }
203 void VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
204 void VisitOpaqueValueExpr(OpaqueValueExpr *E);
206 void VisitPseudoObjectExpr(PseudoObjectExpr *E) {
207 if (E->isGLValue()) {
208 LValue LV = CGF.EmitPseudoObjectLValue(E);
209 return EmitFinalDestCopy(E->getType(), LV);
212 AggValueSlot Slot = EnsureSlot(E->getType());
215 E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct;
218 CGF.EmitPseudoObjectRValue(E, Slot);
221 E->getType());
224 void VisitVAArgExpr(VAArgExpr *E);
225 void VisitCXXParenListInitExpr(CXXParenListInitExpr *E);
229 void EmitInitializationToLValue(Expr *E, LValue Address);
232 void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
233 void VisitAtomicExpr(AtomicExpr *E) {
234 RValue Res = CGF.EmitAtomicExpr(E);
235 EmitFinalDestCopy(E->getType(), Res);
237 void VisitPackIndexingExpr(PackIndexingExpr *E) {
238 Visit(E->getSelectedExpr());
250 void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {
251 LValue LV = CGF.EmitLValue(E);
255 CGF.EmitAtomicLoad(LV, E->getExprLoc(), Dest);
259 EmitFinalDestCopy(E->getType(), LV);
280 const Expr *E, llvm::function_ref<RValue(ReturnValueSlot)> EmitCall) {
281 QualType RetTy = E->getType();
328 Src.getAggregatePointer(E->getType(), CGF));
329 EmitFinalDestCopy(E->getType(), Src);
414 AggExprEmitter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
418 LValue Array = CGF.EmitLValue(E->getSubExpr());
423 Ctx.getAsConstantArrayType(E->getSubExpr()->getType());
426 RecordDecl *Record = E->getType()->castAs<RecordType>()->getDecl();
431 "Expected std::initializer_list first field to be const E *");
434 AggValueSlot Dest = EnsureSlot(E->getType());
435 LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
454 "Expected std::initializer_list second field to be const E *");
467 /// Determine if E is a trivial array filler, that is, one that is
469 static bool isTrivialFiller(Expr *E) {
470 if (!E)
473 if (isa<ImplicitValueInitExpr>(E))
476 if (auto *ILE = dyn_cast<InitListExpr>(E)) {
482 if (auto *Cons = dyn_cast_or_null<CXXConstructExpr>(E))
684 void AggExprEmitter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E){
685 Visit(E->getSubExpr());
697 AggExprEmitter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
699 E->getType().isPODType(CGF.getContext())) {
702 EmitAggLoadOfLValue(E);
706 AggValueSlot Slot = EnsureSlot(E->getType());
715 CGF.EmitAggExpr(E->getInitializer(), Slot);
718 if (QualType::DestructionKind DtorKind = E->getType().isDestructedType())
720 CGF.getCleanupKind(DtorKind), Slot.getAddress(), E->getType(),
735 void AggExprEmitter::VisitCastExpr(CastExpr *E) {
736 if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
738 switch (E->getCastKind()) {
741 assert(isa<CXXDynamicCastExpr>(E) && "CK_Dynamic without a dynamic_cast?");
742 LValue LV = CGF.EmitCheckedLValue(E->getSubExpr(),
746 CGF.EmitDynamicCast(LV.getAddress(), cast<CXXDynamicCastExpr>(E));
748 CGF.CGM.ErrorUnsupported(E, "non-simple lvalue dynamic_cast");
751 CGF.CGM.ErrorUnsupported(E, "lvalue dynamic_cast with a destination");
758 CGF.EmitAnyExpr(E->getSubExpr(), AggValueSlot::ignored(),
764 QualType Ty = E->getSubExpr()->getType();
766 EmitInitializationToLValue(E->getSubExpr(),
773 CGF.EmitAnyExpr(E->getSubExpr(), AggValueSlot::ignored(),
778 LValue SourceLV = CGF.EmitLValue(E->getSubExpr());
783 CGF.getContext().getTypeSizeInChars(E->getType()).getQuantity());
797 bool isToAtomic = (E->getCastKind() == CK_NonAtomicToAtomic);
800 QualType atomicType = E->getSubExpr()->getType();
801 QualType valueType = E->getType();
811 return Visit(E->getSubExpr());
819 findPeephole(E->getSubExpr(), peepholeTarget, CGF.getContext())) {
821 E->getType()) &&
848 CGF.EmitAggExpr(E->getSubExpr(), valueDest);
856 CGF.EmitAggExpr(E->getSubExpr(), atomicSlot);
863 return Visit(E->getSubExpr());
868 if (E->getSubExpr()->getType().isVolatileQualified()) {
871 E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct;
874 EnsureDest(E->getType());
875 Visit(E->getSubExpr());
879 E->getType());
887 Visit(E->getSubExpr());
893 assert(CGF.getContext().hasSameUnqualifiedType(E->getSubExpr()->getType(),
894 E->getType()) &&
896 Visit(E->getSubExpr());
959 void AggExprEmitter::VisitCallExpr(const CallExpr *E) {
960 if (E->getCallReturnType(CGF.getContext())->isReferenceType()) {
961 EmitAggLoadOfLValue(E);
965 withReturnValueSlot(E, [&](ReturnValueSlot Slot) {
966 return CGF.EmitCallExpr(E, Slot);
970 void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
971 withReturnValueSlot(E, [&](ReturnValueSlot Slot) {
972 return CGF.EmitObjCMessageExpr(E, Slot);
976 void AggExprEmitter::VisitBinComma(const BinaryOperator *E) {
977 CGF.EmitIgnoredExpr(E->getLHS());
978 Visit(E->getRHS());
981 void AggExprEmitter::VisitStmtExpr(const StmtExpr *E) {
983 CGF.EmitCompoundStmt(*E->getSubStmt(), true, Dest);
993 const BinaryOperator *E, llvm::Value *LHS,
996 QualType ArgTy = E->getLHS()->getType();
1042 void AggExprEmitter::VisitBinCmp(const BinaryOperator *E) {
1046 assert(CGF.getContext().hasSameType(E->getLHS()->getType(),
1047 E->getRHS()->getType()));
1049 CGF.getContext().CompCategories.getInfoForType(E->getType());
1053 QualType ArgTy = E->getLHS()->getType();
1058 return CGF.ErrorUnsupported(E, "aggregate three-way comparison");
1063 auto EmitOperand = [&](Expr *E) -> std::pair<Value *, Value *> {
1064 RValue RV = CGF.EmitAnyExpr(E);
1068 return {RV.getAggregatePointer(E->getType(), CGF), nullptr};
1072 auto LHSValues = EmitOperand(E->getLHS()),
1073 RHSValues = EmitOperand(E->getRHS());
1076 Value *Cmp = EmitCompare(Builder, CGF, E, LHSValues.first, RHSValues.first,
1081 Value *CmpImag = EmitCompare(Builder, CGF, E, LHSValues.second,
1110 EnsureDest(E->getType());
1111 LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1122 void AggExprEmitter::VisitBinaryOperator(const BinaryOperator *E) {
1123 if (E->getOpcode() == BO_PtrMemD || E->getOpcode() == BO_PtrMemI)
1124 VisitPointerToDataMemberBinaryOperator(E);
1126 CGF.ErrorUnsupported(E, "aggregate binary expression");
1130 const BinaryOperator *E) {
1131 LValue LV = CGF.EmitPointerToDataMemberBinaryExpr(E);
1132 EmitFinalDestCopy(E->getType(), LV);
1137 static bool isBlockVarRef(const Expr *E) {
1139 E = E->IgnoreParens();
1142 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
1150 if (const BinaryOperator *op = dyn_cast<BinaryOperator>(E)) {
1165 = dyn_cast<AbstractConditionalOperator>(E)) {
1171 = dyn_cast<OpaqueValueExpr>(E)) {
1179 } else if (const CastExpr *cast = dyn_cast<CastExpr>(E)) {
1186 } else if (const UnaryOperator *uop = dyn_cast<UnaryOperator>(E)) {
1190 } else if (const MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
1194 } else if (const ArraySubscriptExpr *sub = dyn_cast<ArraySubscriptExpr>(E)) {
1201 void AggExprEmitter::VisitBinAssign(const BinaryOperator *E) {
1204 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(),
1205 E->getRHS()->getType())
1212 if (isBlockVarRef(E->getLHS()) &&
1213 E->getRHS()->HasSideEffects(CGF.getContext())) {
1215 EnsureDest(E->getRHS()->getType());
1216 Visit(E->getRHS());
1219 LValue LHS = CGF.EmitCheckedLValue(E->getLHS(), CodeGenFunction::TCK_Store);
1228 EmitCopy(E->getLHS()->getType(),
1230 needsGC(E->getLHS()->getType()),
1237 LValue LHS = CGF.EmitLValue(E->getLHS());
1243 EnsureDest(E->getRHS()->getType());
1244 Visit(E->getRHS());
1251 LHS, AggValueSlot::IsDestructed, needsGC(E->getLHS()->getType()),
1255 CGF.hasVolatileMember(E->getLHS()->getType()))
1258 CGF.EmitAggExpr(E->getRHS(), LHSSlot);
1261 EmitFinalDestCopy(E->getType(), LHS);
1264 E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct)
1266 E->getType());
1270 VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) {
1276 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
1279 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock,
1280 CGF.getProfileCount(E));
1286 E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct;
1293 CGF.incrementProfileCounter(E->getTrueExpr());
1295 CGF.incrementProfileCounter(E);
1296 Visit(E->getTrueExpr());
1311 CGF.incrementProfileCounter(E->getFalseExpr());
1312 Visit(E->getFalseExpr());
1317 E->getType());
1321 CGF.incrementProfileCounter(E);
1339 void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1343 EnsureDest(E->getType());
1348 Visit(E->getSubExpr());
1352 CGF.EmitCXXTemporary(E->getTemporary(), E->getType(), Dest.getAddress());
1356 AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {
1357 AggValueSlot Slot = EnsureSlot(E->getType());
1358 CGF.EmitCXXConstructExpr(E, Slot);
1362 const CXXInheritedCtorInitExpr *E) {
1363 AggValueSlot Slot = EnsureSlot(E->getType());
1365 E->getConstructor(), E->constructsVBase(), Slot.getAddress(),
1366 E->inheritedFromVBase(), E);
1370 AggExprEmitter::VisitLambdaExpr(LambdaExpr *E) {
1371 AggValueSlot Slot = EnsureSlot(E->getType());
1372 LValue SlotLV = CGF.MakeAddrLValue(Slot.getAddress(), E->getType());
1378 CXXRecordDecl::field_iterator CurField = E->getLambdaClass()->field_begin();
1379 for (LambdaExpr::const_capture_init_iterator i = E->capture_init_begin(),
1380 e = E->capture_init_end();
1403 void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
1405 Visit(E->getSubExpr());
1408 void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1409 QualType T = E->getType();
1414 void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1415 QualType T = E->getType();
1520 static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {
1521 E = E->IgnoreParens();
1522 while (auto *CE = dyn_cast<CastExpr>(E)) {
1525 E = CE->getSubExpr()->IgnoreParens();
1529 if (const IntegerLiteral *IL = dyn_cast<IntegerLiteral>(E))
1532 if (const FloatingLiteral *FL = dyn_cast<FloatingLiteral>(E))
1535 if ((isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) &&
1536 CGF.getTypes().isZeroInitializable(E->getType()))
1539 if (const CastExpr *ICE = dyn_cast<CastExpr>(E))
1541 CGF.getTypes().isPointerZeroInitializable(E->getType()) &&
1542 !E->HasSideEffects(CGF.getContext());
1544 if (const CharacterLiteral *CL = dyn_cast<CharacterLiteral>(E))
1553 AggExprEmitter::EmitInitializationToLValue(Expr *E, LValue LV) {
1557 if (Dest.isZeroed() && isSimpleZero(E, CGF)) {
1560 } else if (isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) {
1562 } else if (isa<NoInitExpr>(E)) {
1566 RValue RV = CGF.EmitReferenceBindingToExpr(E);
1572 CGF.EmitComplexExprIntoLValue(E, LV, /*isInit*/ true);
1576 E, AggValueSlot::forLValue(LV, AggValueSlot::IsDestructed,
1583 CGF.EmitScalarInit(E, /*D=*/nullptr, LV, /*Captured=*/false);
1585 CGF.EmitStoreThroughLValue(RValue::get(CGF.EmitScalarExpr(E)), LV);
1619 void AggExprEmitter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
1620 VisitCXXParenListOrInitListExpr(E, E->getInitExprs(),
1621 E->getInitializedFieldInUnion(),
1622 E->getArrayFiller());
1625 void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
1626 if (E->hadArrayRangeDesignator())
1627 CGF.ErrorUnsupported(E, "GNU array range designator extension");
1629 if (E->isTransparent())
1630 return Visit(E->getInit(0));
1633 E, E->inits(), E->getInitializedFieldInUnion(), E->getArrayFiller());
1798 void AggExprEmitter::VisitArrayInitLoopExpr(const ArrayInitLoopExpr *E,
1801 CodeGenFunction::OpaqueValueMapping binding(CGF, E->getCommonExpr());
1803 Address destPtr = EnsureSlot(E->getType()).getAddress();
1804 uint64_t numElements = E->getArraySize().getZExtValue();
1820 ArrayInitLoopExpr *InnerLoop = dyn_cast<ArrayInitLoopExpr>(E->getSubExpr());
1823 CGF.getContext().getAsArrayType(E->getType())->getElementType();
1872 EmitInitializationToLValue(E->getSubExpr(), elementLV);
1894 void AggExprEmitter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1895 AggValueSlot Dest = EnsureSlot(E->getType());
1897 LValue DestLV = CGF.MakeAddrLValue(Dest.getAddress(), E->getType());
1898 EmitInitializationToLValue(E->getBase(), DestLV);
1899 VisitInitListExpr(E->getUpdater());
1909 static CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) {
1910 if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
1911 E = MTE->getSubExpr();
1912 E = E->IgnoreParenNoopCasts(CGF.getContext());
1915 if (isSimpleZero(E, CGF)) return CharUnits::Zero();
1919 const InitListExpr *ILE = dyn_cast<InitListExpr>(E);
1923 return CGF.getContext().getTypeSizeInChars(E->getType());
1928 if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
1947 const Expr *E = ILE->getInit(ILEElement++);
1954 NumNonZeroBytes += GetNumNonZeroBytesInInit(E, CGF);
1971 static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,
1981 .getBaseElementType(E->getType())->getAs<RecordType>()) {
1988 CharUnits Size = Slot.getPreferredSize(CGF.getContext(), E->getType());
1994 CharUnits NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF);
2015 void CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot) {
2016 assert(E && hasAggregateEvaluationKind(E->getType()) &&
2022 CheckAggExprForMemSetUse(Slot, E, *this);
2024 AggExprEmitter(*this, Slot, Slot.isIgnored()).Visit(const_cast<Expr*>(E));
2027 LValue CodeGenFunction::EmitAggExprToLValue(const Expr *E) {
2028 assert(hasAggregateEvaluationKind(E->getType()) && "Invalid argument!");
2029 Address Temp = CreateMemTemp(E->getType());
2030 LValue LV = MakeAddrLValue(Temp, E->getType());
2031 EmitAggExpr(E, AggValueSlot::forLValue(LV, AggValueSlot::IsNotDestructed,