llvm-project
2212 строк · 83.3 Кб
1//===--- CGExprAgg.cpp - Emit LLVM Code from Aggregate Expressions --------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8//9// This contains code to emit Aggregate Expr nodes as LLVM code.10//11//===----------------------------------------------------------------------===//12//===----------------------------------------------------------------------===//35// Aggregate Expression Emitter36//===----------------------------------------------------------------------===//37//===----------------------------------------------------------------------===//247// Utilities248//===----------------------------------------------------------------------===//249/// EmitAggLoadOfLValue - Given an expression with aggregate type that251/// represents a value lvalue, this method emits the address of the lvalue,252/// then loads the result into DestPtr.253void AggExprEmitter::EmitAggLoadOfLValue(const Expr *E) {254LValue LV = CGF.EmitLValue(E);255}264/// True if the given aggregate type requires special GC API calls.266bool AggExprEmitter::TypeRequiresGCollection(QualType T) {267// Only record types have members that might require garbage collection.268const RecordType *RecordTy = T->getAs<RecordType>();269if (!RecordTy) return false;270}281}342/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.344void AggExprEmitter::EmitFinalDestCopy(QualType type, RValue src) {345assert(src.isAggregate() && "value must be aggregate value!");346LValue srcLV = CGF.MakeAddrLValue(src.getAggregateAddress(), type);347EmitFinalDestCopy(type, srcLV, CodeGenFunction::EVK_RValue);348}349/// EmitFinalDestCopy - Perform the final copy to DestPtr, if desired.351void AggExprEmitter::EmitFinalDestCopy(352QualType type, const LValue &src,353CodeGenFunction::ExprValueKind SrcValueKind) {354// If Dest is ignored, then we're evaluating an aggregate expression355// in a context that doesn't care about the result. Note that loads356// from volatile l-values force the existence of a non-ignored357// destination.358if (Dest.isIgnored())359return;360}388/// Perform a copy from the source into the destination.390///391/// \param type - the type of the aggregate being copied; qualifiers are392/// ignored393void AggExprEmitter::EmitCopy(QualType type, const AggValueSlot &dest,394const AggValueSlot &src) {395if (dest.requiresGCollection()) {396CharUnits sz = dest.getPreferredSize(CGF.getContext(), type);397llvm::Value *size = llvm::ConstantInt::get(CGF.SizeTy, sz.getQuantity());398CGF.CGM.getObjCRuntime().EmitGCMemmoveCollectable(CGF,399dest.getAddress(),400src.getAddress(),401size);402return;403}404}413/// Emit the initializer for a std::initializer_list initialized with a415/// real initializer list.416void417AggExprEmitter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {418// Emit an array containing the elements. The array is externally destructed419// if the std::initializer_list object is.420ASTContext &Ctx = CGF.getContext();421LValue Array = CGF.EmitLValue(E->getSubExpr());422assert(Array.isSimple() && "initializer_list array not a simple lvalue");423Address ArrayPtr = Array.getAddress();424}469/// Determine if E is a trivial array filler, that is, one that is471/// equivalent to zero-initialization.472static bool isTrivialFiller(Expr *E) {473if (!E)474return true;475}492/// Emit initialization of an array from an initializer list. ExprToVisit must494/// be either an InitListEpxr a CXXParenInitListExpr.495void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,496QualType ArrayQTy, Expr *ExprToVisit,497ArrayRef<Expr *> Args, Expr *ArrayFiller) {498uint64_t NumInitElements = Args.size();499}682//===----------------------------------------------------------------------===//684// Visitor Methods685//===----------------------------------------------------------------------===//686}690}698void700AggExprEmitter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {701if (Dest.isPotentiallyAliased() &&702E->getType().isPODType(CGF.getContext())) {703// For a POD type, just emit a load of the lvalue + a copy, because our704// compound literal might alias the destination.705EmitAggLoadOfLValue(E);706return;707}708}726/// Attempt to look through various unimportant expressions to find a728/// cast of the given kind.729static Expr *findPeephole(Expr *op, CastKind kind, const ASTContext &ctx) {730op = op->IgnoreParenNoopCasts(ctx);731if (auto castE = dyn_cast<CastExpr>(op)) {732if (castE->getCastKind() == kind)733return castE->getSubExpr();734}735return nullptr;736}737}961}972}978}983}988}1044}1124}1131}1137/// Is the value of the given expression possibly a reference to or1139/// into a __block variable?1140static bool isBlockVarRef(const Expr *E) {1141// Make sure we look through parens.1142E = E->IgnoreParens();1143}1203}1271}1326}1330}1341}1357void1359AggExprEmitter::VisitCXXConstructExpr(const CXXConstructExpr *E) {1360AggValueSlot Slot = EnsureSlot(E->getType());1361CGF.EmitCXXConstructExpr(E, Slot);1362}1363}1371void1373AggExprEmitter::VisitLambdaExpr(LambdaExpr *E) {1374AggValueSlot Slot = EnsureSlot(E->getType());1375LValue SlotLV = CGF.MakeAddrLValue(Slot.getAddress(), E->getType());1376}1405}1410}1416}1422/// Determine whether the given cast kind is known to always convert values1424/// with all zero bits in their value representation to values with all zero1425/// bits in their value representation.1426static bool castPreservesZero(const CastExpr *CE) {1427switch (CE->getCastKind()) {1428// No-ops.1429case CK_NoOp:1430case CK_UserDefinedConversion:1431case CK_ConstructorConversion:1432case CK_BitCast:1433case CK_ToUnion:1434case CK_ToVoid:1435// Conversions between (possibly-complex) integral, (possibly-complex)1436// floating-point, and bool.1437case CK_BooleanToSignedIntegral:1438case CK_FloatingCast:1439case CK_FloatingComplexCast:1440case CK_FloatingComplexToBoolean:1441case CK_FloatingComplexToIntegralComplex:1442case CK_FloatingComplexToReal:1443case CK_FloatingRealToComplex:1444case CK_FloatingToBoolean:1445case CK_FloatingToIntegral:1446case CK_IntegralCast:1447case CK_IntegralComplexCast:1448case CK_IntegralComplexToBoolean:1449case CK_IntegralComplexToFloatingComplex:1450case CK_IntegralComplexToReal:1451case CK_IntegralRealToComplex:1452case CK_IntegralToBoolean:1453case CK_IntegralToFloating:1454// Reinterpreting integers as pointers and vice versa.1455case CK_IntegralToPointer:1456case CK_PointerToIntegral:1457// Language extensions.1458case CK_VectorSplat:1459case CK_MatrixCast:1460case CK_NonAtomicToAtomic:1461case CK_AtomicToNonAtomic:1462case CK_HLSLVectorTruncation:1463return true;1464}1519/// isSimpleZero - If emitting this value will obviously just cause a store of1521/// zero to memory, return true. This can return false if uncertain, so it just1522/// handles simple cases.1523static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF) {1524E = E->IgnoreParens();1525while (auto *CE = dyn_cast<CastExpr>(E)) {1526if (!castPreservesZero(CE))1527break;1528E = CE->getSubExpr()->IgnoreParens();1529}1530}1553void1556AggExprEmitter::EmitInitializationToLValue(Expr *E, LValue LV) {1557QualType type = LV.getType();1558// FIXME: Ignore result?1559// FIXME: Are initializers affected by volatile?1560if (Dest.isZeroed() && isSimpleZero(E, CGF)) {1561// Storing "i32 0" to a zero'd memory location is a noop.1562return;1563} else if (isa<ImplicitValueInitExpr>(E) || isa<CXXScalarValueInitExpr>(E)) {1564return EmitNullInitializationToLValue(LV);1565} else if (isa<NoInitExpr>(E)) {1566// Do nothing.1567return;1568} else if (type->isReferenceType()) {1569RValue RV = CGF.EmitReferenceBindingToExpr(E);1570return CGF.EmitStoreThroughLValue(RV, LV);1571}1572}1594}1621}1627}1638}1800}1896}1904//===----------------------------------------------------------------------===//1906// Entry Points into this File1907//===----------------------------------------------------------------------===//1908/// GetNumNonZeroBytesInInit - Get an approximate count of the number of1910/// non-zero bytes that will be stored when outputting the initializer for the1911/// specified initializer expression.1912static CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) {1913if (auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))1914E = MTE->getSubExpr();1915E = E->IgnoreParenNoopCasts(CGF.getContext());1916}1970/// CheckAggExprForMemSetUse - If the initializer is large and has a lot of1972/// zeros in it, emit a memset and avoid storing the individual zeros.1973///1974static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E,1975CodeGenFunction &CGF) {1976// If the slot is already known to be zeroed, nothing to do. Don't mess with1977// volatile stores.1978if (Slot.isZeroed() || Slot.isVolatile() || !Slot.getAddress().isValid())1979return;1980}2010/// EmitAggExpr - Emit the computation of the specified expression of aggregate2015/// type. The result is computed into DestPtr. Note that if DestPtr is null,2016/// the value of the aggregate expression is not needed. If VolatileDest is2017/// true, DestPtr cannot be 0.2018void CodeGenFunction::EmitAggExpr(const Expr *E, AggValueSlot Slot) {2019assert(E && hasAggregateEvaluationKind(E->getType()) &&2020"Invalid aggregate expression to emit");2021assert((Slot.getAddress().isValid() || Slot.isIgnored()) &&2022"slot has bits but no address");2023}2029}2040}2047}2066}2087}2213