28#include "llvm/IR/Constants.h"
29#include "llvm/IR/Function.h"
30#include "llvm/IR/GlobalVariable.h"
31#include "llvm/IR/Instruction.h"
32#include "llvm/IR/IntrinsicInst.h"
33#include "llvm/IR/Intrinsics.h"
46class AggExprEmitter :
public StmtVisitor<AggExprEmitter> {
52 AggValueSlot EnsureSlot(QualType
T) {
56 void EnsureDest(QualType
T) {
67 void withReturnValueSlot(
const Expr *E,
68 llvm::function_ref<RValue(ReturnValueSlot)> Fn);
70 void DoZeroInitPadding(uint64_t &PaddingStart, uint64_t PaddingEnd,
71 const FieldDecl *NextField);
74 AggExprEmitter(CodeGenFunction &cgf, AggValueSlot Dest,
bool IsResultUnused)
75 : CGF(cgf), Builder(CGF.Builder), Dest(Dest),
76 IsResultUnused(IsResultUnused) { }
85 void EmitAggLoadOfLValue(
const Expr *E);
89 void EmitFinalDestCopy(QualType
type,
const LValue &src,
92 void EmitFinalDestCopy(QualType
type, RValue src);
93 void EmitCopy(QualType
type,
const AggValueSlot &dest,
94 const AggValueSlot &src);
96 void EmitArrayInit(Address DestPtr, llvm::ArrayType *AType, QualType ArrayQTy,
97 Expr *ExprToVisit, ArrayRef<Expr *> Args,
101 if (CGF.
getLangOpts().getGC() && TypeRequiresGCollection(
T))
106 bool TypeRequiresGCollection(QualType
T);
112 void Visit(Expr *E) {
113 ApplyDebugLocation DL(CGF, E);
114 StmtVisitor<AggExprEmitter>::Visit(E);
117 void VisitStmt(Stmt *S) {
120 void VisitParenExpr(ParenExpr *PE) { Visit(PE->
getSubExpr()); }
121 void VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
122 Visit(
GE->getResultExpr());
124 void VisitCoawaitExpr(CoawaitExpr *E) {
127 void VisitCoyieldExpr(CoyieldExpr *E) {
130 void VisitUnaryCoawait(UnaryOperator *E) { Visit(E->
getSubExpr()); }
131 void VisitUnaryExtension(UnaryOperator *E) { Visit(E->
getSubExpr()); }
132 void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
136 void VisitConstantExpr(ConstantExpr *E) {
139 if (llvm::Value *
Result = ConstantEmitter(CGF).tryEmitConstantExpr(E)) {
142 llvm::TypeSize::getFixed(
152 void VisitDeclRefExpr(DeclRefExpr *E) { EmitAggLoadOfLValue(E); }
153 void VisitMemberExpr(MemberExpr *ME) { EmitAggLoadOfLValue(ME); }
154 void VisitUnaryDeref(UnaryOperator *E) { EmitAggLoadOfLValue(E); }
155 void VisitStringLiteral(StringLiteral *E) { EmitAggLoadOfLValue(E); }
156 void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
157 void VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
158 EmitAggLoadOfLValue(E);
160 void VisitPredefinedExpr(
const PredefinedExpr *E) {
161 EmitAggLoadOfLValue(E);
166 void VisitCallExpr(
const CallExpr *E);
167 void VisitStmtExpr(
const StmtExpr *E);
168 void VisitBinaryOperator(
const BinaryOperator *BO);
169 void VisitPointerToDataMemberBinaryOperator(
const BinaryOperator *BO);
170 void VisitBinAssign(
const BinaryOperator *E);
171 void VisitBinComma(
const BinaryOperator *E);
172 void VisitBinCmp(
const BinaryOperator *E);
173 void VisitCXXRewrittenBinaryOperator(CXXRewrittenBinaryOperator *E) {
177 void VisitObjCMessageExpr(ObjCMessageExpr *E);
178 void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
179 EmitAggLoadOfLValue(E);
182 void VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E);
183 void VisitAbstractConditionalOperator(
const AbstractConditionalOperator *CO);
184 void VisitChooseExpr(
const ChooseExpr *CE);
185 void VisitInitListExpr(InitListExpr *E);
186 void VisitCXXParenListOrInitListExpr(Expr *ExprToVisit, ArrayRef<Expr *> Args,
187 FieldDecl *InitializedFieldInUnion,
189 void VisitArrayInitLoopExpr(
const ArrayInitLoopExpr *E,
190 llvm::Value *outerBegin =
nullptr);
191 void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
192 void VisitNoInitExpr(NoInitExpr *E) { }
193 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
194 CodeGenFunction::CXXDefaultArgExprScope Scope(CGF, DAE);
197 void VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) {
198 CodeGenFunction::CXXDefaultInitExprScope Scope(CGF, DIE);
201 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
202 void VisitCXXConstructExpr(
const CXXConstructExpr *E);
203 void VisitCXXInheritedCtorInitExpr(
const CXXInheritedCtorInitExpr *E);
205 void VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E);
206 void VisitExprWithCleanups(ExprWithCleanups *E);
207 void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E);
208 void VisitCXXTypeidExpr(CXXTypeidExpr *E) { EmitAggLoadOfLValue(E); }
209 void VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E);
210 void VisitOpaqueValueExpr(OpaqueValueExpr *E);
212 void VisitPseudoObjectExpr(PseudoObjectExpr *E) {
215 return EmitFinalDestCopy(E->
getType(), LV);
218 AggValueSlot Slot = EnsureSlot(E->
getType());
219 bool NeedsDestruction =
222 if (NeedsDestruction)
225 if (NeedsDestruction)
230 void VisitVAArgExpr(VAArgExpr *E);
231 void VisitCXXParenListInitExpr(CXXParenListInitExpr *E);
232 void VisitCXXParenListOrInitListExpr(Expr *ExprToVisit, ArrayRef<Expr *> Args,
235 void EmitInitializationToLValue(Expr *E, LValue Address);
236 void EmitNullInitializationToLValue(LValue Address);
239 void VisitAtomicExpr(AtomicExpr *E) {
241 EmitFinalDestCopy(E->
getType(), Res);
243 void VisitPackIndexingExpr(PackIndexingExpr *E) {
256void AggExprEmitter::EmitAggLoadOfLValue(
const Expr *E) {
265 EmitFinalDestCopy(E->
getType(), LV);
269bool AggExprEmitter::TypeRequiresGCollection(QualType
T) {
285void AggExprEmitter::withReturnValueSlot(
286 const Expr *E, llvm::function_ref<RValue(ReturnValueSlot)> EmitCall) {
288 bool RequiresDestruction =
298 (RequiresDestruction && Dest.
isIgnored());
302 EHScopeStack::stable_iterator LifetimeEndBlock;
303 llvm::IntrinsicInst *LifetimeStartInst =
nullptr;
311 assert(LifetimeStartInst->getIntrinsicID() ==
312 llvm::Intrinsic::lifetime_start &&
313 "Last insertion wasn't a lifetime.start?");
322 EmitCall(ReturnValueSlot(RetAddr, Dest.
isVolatile(), IsResultUnused,
330 EmitFinalDestCopy(E->
getType(), Src);
332 if (!RequiresDestruction && LifetimeStartInst) {
342void AggExprEmitter::EmitFinalDestCopy(QualType
type, RValue src) {
343 assert(src.
isAggregate() &&
"value must be aggregate value!");
349void AggExprEmitter::EmitFinalDestCopy(
350 QualType
type,
const LValue &src,
384 EmitCopy(
type, Dest, srcAgg);
391void AggExprEmitter::EmitCopy(QualType
type,
const AggValueSlot &dest,
392 const AggValueSlot &src) {
415AggExprEmitter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
420 assert(Array.isSimple() &&
"initializer_list array not a simple lvalue");
421 Address ArrayPtr = Array.getAddress();
423 const ConstantArrayType *ArrayType =
425 assert(ArrayType &&
"std::initializer_list constructed from non-array");
429 assert(Field !=
Record->field_end() &&
432 "Expected std::initializer_list first field to be const E *");
435 AggValueSlot Dest = EnsureSlot(E->
getType());
441 assert(Field !=
Record->field_end() &&
442 "Expected std::initializer_list to have two fields");
444 llvm::Value *
Size = Builder.getInt(ArrayType->
getSize());
452 assert(
Field->getType()->isPointerType() &&
455 "Expected std::initializer_list second field to be const E *");
456 llvm::Value *
Zero = llvm::ConstantInt::get(CGF.
PtrDiffTy, 0);
457 llvm::Value *IdxEnd[] = {
Zero,
Size };
458 llvm::Value *ArrayEnd = Builder.CreateInBoundsGEP(
464 assert(++Field ==
Record->field_end() &&
465 "Expected std::initializer_list to only have two fields");
477 if (
auto *ILE = dyn_cast<InitListExpr>(E)) {
478 if (ILE->getNumInits())
483 if (
auto *Cons = dyn_cast_or_null<CXXConstructExpr>(E))
484 return Cons->getConstructor()->isDefaultConstructor() &&
485 Cons->getConstructor()->isTrivial();
505 SrcTy = VT->getElementType();
506 assert(StoreList.size() <= VT->getNumElements() &&
507 "Cannot perform HLSL flat cast when vector source \
508 object has less elements than flattened destination \
512 for (
unsigned I = 0, Size = StoreList.size(); I < Size; I++) {
513 LValue DestLVal = StoreList[I];
533 assert(StoreList.size() <= LoadList.size() &&
534 "Cannot perform HLSL elementwise cast when flattened source object \
535 has less elements than flattened destination object.");
538 for (
unsigned I = 0, E = StoreList.size(); I < E; I++) {
539 LValue DestLVal = StoreList[I];
540 LValue SrcLVal = LoadList[I];
542 assert(RVal.
isScalar() &&
"All flattened source values should be scalars");
545 DestLVal.getType(), Loc);
552void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType,
553 QualType ArrayQTy, Expr *ExprToVisit,
554 ArrayRef<Expr *> Args, Expr *ArrayFiller) {
555 uint64_t NumInitElements = Args.size();
557 uint64_t NumArrayElements = AType->getNumElements();
558 for (
const auto *
Init : Args) {
559 if (
const auto *Embed = dyn_cast<EmbedExpr>(
Init->IgnoreParenImpCasts())) {
560 NumInitElements += Embed->getDataElementCount() - 1;
561 if (NumInitElements > NumArrayElements) {
562 NumInitElements = NumArrayElements;
568 assert(NumInitElements <= NumArrayElements);
570 QualType elementType =
573 CharUnits elementAlign =
580 if (NumInitElements * elementSize.
getQuantity() > 16 &&
582 CodeGen::CodeGenModule &CGM = CGF.
CGM;
583 ConstantEmitter Emitter(CGF);
588 if (llvm::Constant *
C =
589 Emitter.tryEmitForInitializer(ExprToVisit, AS, GVArrayQTy)) {
590 auto GV =
new llvm::GlobalVariable(
592 true, llvm::GlobalValue::PrivateLinkage,
C,
594 nullptr, llvm::GlobalVariable::NotThreadLocal,
596 Emitter.finalize(GV);
599 Address GVAddr(GV, GV->getValueType(), Align);
600 EmitFinalDestCopy(ArrayQTy, CGF.
MakeAddrLValue(GVAddr, GVArrayQTy));
610 CodeGenFunction::CleanupDeactivationScope deactivation(CGF);
614 CodeGenFunction::AllocaTrackerRAII allocaTracker(CGF);
619 llvm::Instruction *dominatingIP =
620 Builder.CreateFlagLoad(llvm::ConstantInt::getNullValue(CGF.
Int8PtrTy));
622 "arrayinit.endOfInit");
623 Builder.CreateStore(begin, endOfInit);
628 .AddAuxAllocas(allocaTracker.Take());
634 llvm::Value *one = llvm::ConstantInt::get(CGF.
SizeTy, 1);
637 llvm::Value *element = begin;
638 if (ArrayIndex > 0) {
639 element = Builder.CreateInBoundsGEP(
640 llvmElementType, begin,
641 llvm::ConstantInt::get(CGF.
SizeTy, ArrayIndex),
"arrayinit.element");
647 Builder.CreateStore(element, endOfInit);
651 Address(element, llvmElementType, elementAlign), elementType);
652 EmitInitializationToLValue(
Init, elementLV);
656 unsigned ArrayIndex = 0;
658 for (uint64_t i = 0; i != NumInitElements; ++i) {
659 if (ArrayIndex >= NumInitElements)
661 if (
auto *EmbedS = dyn_cast<EmbedExpr>(Args[i]->IgnoreParenImpCasts())) {
662 EmbedS->doForEachDataElement(Emit, ArrayIndex);
664 Emit(Args[i], ArrayIndex);
675 if (NumInitElements != NumArrayElements &&
676 !(Dest.
isZeroed() && hasTrivialFiller &&
683 llvm::Value *element = begin;
684 if (NumInitElements) {
685 element = Builder.CreateInBoundsGEP(
686 llvmElementType, element,
687 llvm::ConstantInt::get(CGF.
SizeTy, NumInitElements),
689 if (endOfInit.
isValid()) Builder.CreateStore(element, endOfInit);
693 llvm::Value *end = Builder.CreateInBoundsGEP(
694 llvmElementType, begin,
695 llvm::ConstantInt::get(CGF.
SizeTy, NumArrayElements),
"arrayinit.end");
697 llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
702 llvm::PHINode *currentElement =
703 Builder.CreatePHI(element->getType(), 2,
"arrayinit.cur");
704 currentElement->addIncoming(element, entryBB);
713 CodeGenFunction::RunCleanupsScope CleanupsScope(CGF);
715 Address(currentElement, llvmElementType, elementAlign), elementType);
717 EmitInitializationToLValue(ArrayFiller, elementLV);
719 EmitNullInitializationToLValue(elementLV);
723 llvm::Value *nextElement = Builder.CreateInBoundsGEP(
724 llvmElementType, currentElement, one,
"arrayinit.next");
727 if (endOfInit.
isValid()) Builder.CreateStore(nextElement, endOfInit);
730 llvm::Value *done = Builder.CreateICmpEQ(nextElement, end,
733 Builder.CreateCondBr(done, endBB, bodyBB);
734 currentElement->addIncoming(nextElement, Builder.GetInsertBlock());
744void AggExprEmitter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E){
748void AggExprEmitter::VisitOpaqueValueExpr(OpaqueValueExpr *e) {
757AggExprEmitter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
762 EmitAggLoadOfLValue(E);
766 AggValueSlot Slot = EnsureSlot(E->
getType());
788 if (
auto castE = dyn_cast<CastExpr>(op)) {
789 if (castE->getCastKind() == kind)
790 return castE->getSubExpr();
795void AggExprEmitter::VisitCastExpr(
CastExpr *E) {
796 if (
const auto *ECE = dyn_cast<ExplicitCastExpr>(E))
831 case CK_LValueToRValueBitCast: {
839 Address SourceAddress = SourceLV.getAddress().withElementType(CGF.
Int8Ty);
841 llvm::Value *SizeVal = llvm::ConstantInt::get(
844 Builder.CreateMemCpy(DestAddress, SourceAddress, SizeVal);
848 case CK_DerivedToBase:
849 case CK_BaseToDerived:
850 case CK_UncheckedDerivedToBase: {
851 llvm_unreachable(
"cannot perform hierarchy conversion in EmitAggExpr: "
852 "should have been unpacked before we got here");
855 case CK_NonAtomicToAtomic:
856 case CK_AtomicToNonAtomic: {
857 bool isToAtomic = (E->
getCastKind() == CK_NonAtomicToAtomic);
861 QualType valueType = E->
getType();
862 if (isToAtomic) std::swap(
atomicType, valueType);
866 atomicType->castAs<AtomicType>()->getValueType()));
875 (isToAtomic ? CK_AtomicToNonAtomic : CK_NonAtomicToAtomic);
882 "peephole significantly changed types?");
889 AggValueSlot valueDest = Dest;
914 AggValueSlot atomicSlot =
918 Address valueAddr = Builder.CreateStructGEP(atomicSlot.
getAddress(), 0);
920 return EmitFinalDestCopy(valueType, rvalue);
922 case CK_AddressSpaceConversion:
925 case CK_LValueToRValue:
946 case CK_HLSLArrayRValue:
949 case CK_HLSLAggregateSplatCast: {
951 QualType SrcTy = Src->
getType();
957 "RHS of HLSL splat cast must be a scalar.");
962 case CK_HLSLElementwiseCast: {
964 QualType SrcTy = Src->
getType();
972 "HLSL Elementwise cast doesn't handle splatting.");
976 "Can't perform HLSL Aggregate cast on a complex type.");
984 case CK_UserDefinedConversion:
985 case CK_ConstructorConversion:
988 "Implicit cast types must be compatible");
992 case CK_LValueBitCast:
993 llvm_unreachable(
"should not be emitting lvalue bitcast as rvalue");
997 case CK_ArrayToPointerDecay:
998 case CK_FunctionToPointerDecay:
999 case CK_NullToPointer:
1000 case CK_NullToMemberPointer:
1001 case CK_BaseToDerivedMemberPointer:
1002 case CK_DerivedToBaseMemberPointer:
1003 case CK_MemberPointerToBoolean:
1004 case CK_ReinterpretMemberPointer:
1005 case CK_IntegralToPointer:
1006 case CK_PointerToIntegral:
1007 case CK_PointerToBoolean:
1009 case CK_VectorSplat:
1010 case CK_IntegralCast:
1011 case CK_BooleanToSignedIntegral:
1012 case CK_IntegralToBoolean:
1013 case CK_IntegralToFloating:
1014 case CK_FloatingToIntegral:
1015 case CK_FloatingToBoolean:
1016 case CK_FloatingCast:
1017 case CK_CPointerToObjCPointerCast:
1018 case CK_BlockPointerToObjCPointerCast:
1019 case CK_AnyPointerToBlockPointerCast:
1020 case CK_ObjCObjectLValueCast:
1021 case CK_FloatingRealToComplex:
1022 case CK_FloatingComplexToReal:
1023 case CK_FloatingComplexToBoolean:
1024 case CK_FloatingComplexCast:
1025 case CK_FloatingComplexToIntegralComplex:
1026 case CK_IntegralRealToComplex:
1027 case CK_IntegralComplexToReal:
1028 case CK_IntegralComplexToBoolean:
1029 case CK_IntegralComplexCast:
1030 case CK_IntegralComplexToFloatingComplex:
1031 case CK_ARCProduceObject:
1032 case CK_ARCConsumeObject:
1033 case CK_ARCReclaimReturnedObject:
1034 case CK_ARCExtendBlockObject:
1035 case CK_CopyAndAutoreleaseBlockObject:
1036 case CK_BuiltinFnToFnPtr:
1037 case CK_ZeroToOCLOpaqueType:
1039 case CK_HLSLVectorTruncation:
1041 case CK_IntToOCLSampler:
1042 case CK_FloatingToFixedPoint:
1043 case CK_FixedPointToFloating:
1044 case CK_FixedPointCast:
1045 case CK_FixedPointToBoolean:
1046 case CK_FixedPointToIntegral:
1047 case CK_IntegralToFixedPoint:
1048 llvm_unreachable(
"cast kind invalid for aggregate types");
1052void AggExprEmitter::VisitCallExpr(
const CallExpr *E) {
1054 EmitAggLoadOfLValue(E);
1058 withReturnValueSlot(E, [&](ReturnValueSlot Slot) {
1063void AggExprEmitter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1064 withReturnValueSlot(E, [&](ReturnValueSlot Slot) {
1069void AggExprEmitter::VisitBinComma(
const BinaryOperator *E) {
1074void AggExprEmitter::VisitStmtExpr(
const StmtExpr *E) {
1075 CodeGenFunction::StmtExprEvaluation eval(CGF);
1088 const char *NameSuffix =
"") {
1091 ArgTy = CT->getElementType();
1095 "member pointers may only be compared for equality");
1097 CGF, LHS, RHS, MPT,
false);
1101 struct CmpInstInfo {
1103 llvm::CmpInst::Predicate FCmp;
1104 llvm::CmpInst::Predicate SCmp;
1105 llvm::CmpInst::Predicate UCmp;
1107 CmpInstInfo InstInfo = [&]() -> CmpInstInfo {
1108 using FI = llvm::FCmpInst;
1109 using II = llvm::ICmpInst;
1112 return {
"cmp.lt", FI::FCMP_OLT, II::ICMP_SLT, II::ICMP_ULT};
1114 return {
"cmp.gt", FI::FCMP_OGT, II::ICMP_SGT, II::ICMP_UGT};
1116 return {
"cmp.eq", FI::FCMP_OEQ, II::ICMP_EQ, II::ICMP_EQ};
1118 llvm_unreachable(
"Unrecognised CompareKind enum");
1122 return Builder.CreateFCmp(InstInfo.FCmp, LHS, RHS,
1123 llvm::Twine(InstInfo.Name) + NameSuffix);
1127 return Builder.CreateICmp(Inst, LHS, RHS,
1128 llvm::Twine(InstInfo.Name) + NameSuffix);
1131 llvm_unreachable(
"unsupported aggregate binary expression should have "
1132 "already been handled");
1135void AggExprEmitter::VisitBinCmp(
const BinaryOperator *E) {
1136 using llvm::BasicBlock;
1137 using llvm::PHINode;
1141 const ComparisonCategoryInfo &CmpInfo =
1144 "cannot copy non-trivially copyable aggregate");
1156 auto EmitOperand = [&](Expr *E) -> std::pair<Value *, Value *> {
1165 auto LHSValues = EmitOperand(E->
getLHS()),
1166 RHSValues = EmitOperand(E->
getRHS());
1169 Value *Cmp =
EmitCompare(Builder, CGF, E, LHSValues.first, RHSValues.first,
1170 K, IsComplex ?
".r" :
"");
1175 RHSValues.second, K,
".i");
1176 return Builder.CreateAnd(Cmp, CmpImag,
"and.eq");
1178 auto EmitCmpRes = [&](
const ComparisonCategoryInfo::ValueInfo *VInfo) {
1179 return Builder.getInt(VInfo->getIntValue());
1187 Builder.CreateSelect(EmitCmp(
CK_Less), EmitCmpRes(CmpInfo.
getLess()),
1189 Select = Builder.CreateSelect(EmitCmp(
CK_Equal),
1191 SelectOne,
"sel.eq");
1193 Value *SelectEq = Builder.CreateSelect(
1198 SelectEq,
"sel.gt");
1199 Select = Builder.CreateSelect(
1200 EmitCmp(
CK_Less), EmitCmpRes(CmpInfo.
getLess()), SelectGT,
"sel.lt");
1215void AggExprEmitter::VisitBinaryOperator(
const BinaryOperator *E) {
1217 VisitPointerToDataMemberBinaryOperator(E);
1222void AggExprEmitter::VisitPointerToDataMemberBinaryOperator(
1223 const BinaryOperator *E) {
1225 EmitFinalDestCopy(E->
getType(), LV);
1235 if (
const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
1236 const VarDecl *var = dyn_cast<VarDecl>(DRE->getDecl());
1237 return (var && var->hasAttr<BlocksAttr>());
1246 if (op->isAssignmentOp() || op->isPtrMemOp())
1250 if (op->getOpcode() == BO_Comma)
1258 = dyn_cast<AbstractConditionalOperator>(E)) {
1264 = dyn_cast<OpaqueValueExpr>(E)) {
1265 if (
const Expr *src = op->getSourceExpr())
1272 }
else if (
const CastExpr *
cast = dyn_cast<CastExpr>(E)) {
1273 if (
cast->getCastKind() == CK_LValueToRValue)
1279 }
else if (
const UnaryOperator *uop = dyn_cast<UnaryOperator>(E)) {
1283 }
else if (
const MemberExpr *mem = dyn_cast<MemberExpr>(E)) {
1294void AggExprEmitter::VisitBinAssign(
const BinaryOperator *E) {
1300 &&
"Invalid assignment");
1316 if (LHS.getType()->isAtomicType() ||
1335 if (LHS.getType()->isAtomicType() ||
1355 EmitFinalDestCopy(E->
getType(), LHS);
1363void AggExprEmitter::
1364VisitAbstractConditionalOperator(
const AbstractConditionalOperator *E) {
1370 CodeGenFunction::OpaqueValueMapping binding(CGF, E);
1372 CodeGenFunction::ConditionalEvaluation eval(CGF);
1378 bool destructNonTrivialCStruct =
1379 !isExternallyDestructed &&
1381 isExternallyDestructed |= destructNonTrivialCStruct;
1393 assert(CGF.
HaveInsertPoint() &&
"expression evaluation ended with no IP!");
1394 CGF.
Builder.CreateBr(ContBlock);
1409 if (destructNonTrivialCStruct)
1418void AggExprEmitter::VisitChooseExpr(
const ChooseExpr *CE) {
1422void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
1433void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1445 if (!wasExternallyDestructed)
1450AggExprEmitter::VisitCXXConstructExpr(
const CXXConstructExpr *E) {
1451 AggValueSlot Slot = EnsureSlot(E->
getType());
1455void AggExprEmitter::VisitCXXInheritedCtorInitExpr(
1456 const CXXInheritedCtorInitExpr *E) {
1457 AggValueSlot Slot = EnsureSlot(E->
getType());
1464AggExprEmitter::VisitLambdaExpr(
LambdaExpr *E) {
1465 AggValueSlot Slot = EnsureSlot(E->
getType());
1470 CodeGenFunction::CleanupDeactivationScope scope(CGF);
1475 i != e; ++i, ++CurField) {
1478 if (CurField->hasCapturedVLAType()) {
1483 EmitInitializationToLValue(*i, LV);
1487 CurField->getType().isDestructedType()) {
1488 assert(LV.isSimple());
1491 CurField->getType(),
1497void AggExprEmitter::VisitExprWithCleanups(ExprWithCleanups *E) {
1498 CodeGenFunction::RunCleanupsScope cleanups(CGF);
1502void AggExprEmitter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1504 AggValueSlot Slot = EnsureSlot(
T);
1508void AggExprEmitter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1510 AggValueSlot Slot = EnsureSlot(
T);
1521 case CK_UserDefinedConversion:
1522 case CK_ConstructorConversion:
1528 case CK_BooleanToSignedIntegral:
1529 case CK_FloatingCast:
1530 case CK_FloatingComplexCast:
1531 case CK_FloatingComplexToBoolean:
1532 case CK_FloatingComplexToIntegralComplex:
1533 case CK_FloatingComplexToReal:
1534 case CK_FloatingRealToComplex:
1535 case CK_FloatingToBoolean:
1536 case CK_FloatingToIntegral:
1537 case CK_IntegralCast:
1538 case CK_IntegralComplexCast:
1539 case CK_IntegralComplexToBoolean:
1540 case CK_IntegralComplexToFloatingComplex:
1541 case CK_IntegralComplexToReal:
1542 case CK_IntegralRealToComplex:
1543 case CK_IntegralToBoolean:
1544 case CK_IntegralToFloating:
1546 case CK_IntegralToPointer:
1547 case CK_PointerToIntegral:
1549 case CK_VectorSplat:
1551 case CK_NonAtomicToAtomic:
1552 case CK_AtomicToNonAtomic:
1553 case CK_HLSLVectorTruncation:
1554 case CK_HLSLElementwiseCast:
1555 case CK_HLSLAggregateSplatCast:
1558 case CK_BaseToDerivedMemberPointer:
1559 case CK_DerivedToBaseMemberPointer:
1560 case CK_MemberPointerToBoolean:
1561 case CK_NullToMemberPointer:
1562 case CK_ReinterpretMemberPointer:
1566 case CK_AnyPointerToBlockPointerCast:
1567 case CK_BlockPointerToObjCPointerCast:
1568 case CK_CPointerToObjCPointerCast:
1569 case CK_ObjCObjectLValueCast:
1570 case CK_IntToOCLSampler:
1571 case CK_ZeroToOCLOpaqueType:
1575 case CK_FixedPointCast:
1576 case CK_FixedPointToBoolean:
1577 case CK_FixedPointToFloating:
1578 case CK_FixedPointToIntegral:
1579 case CK_FloatingToFixedPoint:
1580 case CK_IntegralToFixedPoint:
1584 case CK_AddressSpaceConversion:
1585 case CK_BaseToDerived:
1586 case CK_DerivedToBase:
1588 case CK_NullToPointer:
1589 case CK_PointerToBoolean:
1594 case CK_ARCConsumeObject:
1595 case CK_ARCExtendBlockObject:
1596 case CK_ARCProduceObject:
1597 case CK_ARCReclaimReturnedObject:
1598 case CK_CopyAndAutoreleaseBlockObject:
1599 case CK_ArrayToPointerDecay:
1600 case CK_FunctionToPointerDecay:
1601 case CK_BuiltinFnToFnPtr:
1603 case CK_LValueBitCast:
1604 case CK_LValueToRValue:
1605 case CK_LValueToRValueBitCast:
1606 case CK_UncheckedDerivedToBase:
1607 case CK_HLSLArrayRValue:
1610 llvm_unreachable(
"Unhandled clang::CastKind enum");
1618 while (
auto *CE = dyn_cast<CastExpr>(E)) {
1626 return IL->getValue() == 0;
1629 return FL->getValue().isPosZero();
1635 if (
const CastExpr *ICE = dyn_cast<CastExpr>(E))
1636 return ICE->getCastKind() == CK_NullToPointer &&
1641 return CL->getValue() == 0;
1649AggExprEmitter::EmitInitializationToLValue(Expr *E, LValue LV) {
1650 QualType
type = LV.getType();
1657 return EmitNullInitializationToLValue(LV);
1661 }
else if (
type->isReferenceType()) {
1669void AggExprEmitter::EmitNullInitializationToLValue(LValue lv) {
1670 QualType
type = lv.getType();
1682 if (lv.isBitField()) {
1685 assert(lv.isSimple());
1696void AggExprEmitter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
1702void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
1709 VisitCXXParenListOrInitListExpr(
1713void AggExprEmitter::VisitCXXParenListOrInitListExpr(
1714 Expr *ExprToVisit, ArrayRef<Expr *> InitExprs,
1715 FieldDecl *InitializedFieldInUnion, Expr *ArrayFiller) {
1722 if (llvm::Constant *
C =
1723 CGF.
CGM.EmitConstantExpr(ExprToVisit, ExprToVisit->
getType(), &CGF)) {
1724 llvm::GlobalVariable* GV =
1725 new llvm::GlobalVariable(CGF.
CGM.
getModule(),
C->getType(),
true,
1726 llvm::GlobalValue::InternalLinkage,
C,
"");
1727 EmitFinalDestCopy(ExprToVisit->
getType(),
1745 AggValueSlot Dest = EnsureSlot(ExprToVisit->
getType());
1753 InitExprs, ArrayFiller);
1759 assert(InitExprs.size() == 0 &&
1760 "you can only use an empty initializer with VLAs");
1766 "Only support structs/unions here!");
1772 unsigned NumInitElements = InitExprs.size();
1777 CodeGenFunction::CleanupDeactivationScope DeactivateCleanups(CGF);
1779 unsigned curInitIndex = 0;
1782 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(record)) {
1783 assert(NumInitElements >= CXXRD->getNumBases() &&
1784 "missing initializer for base class");
1785 for (
auto &Base : CXXRD->bases()) {
1786 assert(!
Base.isVirtual() &&
"should not see vbases here");
1787 auto *BaseRD =
Base.getType()->getAsCXXRecordDecl();
1797 CGF.
EmitAggExpr(InitExprs[curInitIndex++], AggSlot);
1800 Base.getType().isDestructedType())
1806 CodeGenFunction::FieldConstructionScope FCS(CGF, Dest.
getAddress());
1808 const bool ZeroInitPadding =
1814 if (!InitializedFieldInUnion) {
1820 for (
const auto *Field : record->
fields())
1822 (
Field->isUnnamedBitField() ||
Field->isAnonymousStructOrUnion()) &&
1823 "Only unnamed bitfields or anonymous class allowed");
1829 FieldDecl *
Field = InitializedFieldInUnion;
1832 if (NumInitElements) {
1834 EmitInitializationToLValue(InitExprs[0], FieldLoc);
1835 if (ZeroInitPadding) {
1839 DoZeroInitPadding(FieldSize, TotalSize,
nullptr);
1843 if (ZeroInitPadding)
1844 EmitNullInitializationToLValue(DestLV);
1846 EmitNullInitializationToLValue(FieldLoc);
1856 for (
const auto *field : record->
fields()) {
1858 if (field->getType()->isIncompleteArrayType())
1862 if (field->isUnnamedBitField())
1868 if (curInitIndex == NumInitElements && Dest.
isZeroed() &&
1872 if (ZeroInitPadding)
1873 DoZeroInitPadding(PaddingStart,
1880 if (curInitIndex < NumInitElements) {
1882 EmitInitializationToLValue(InitExprs[curInitIndex++], LV);
1885 EmitNullInitializationToLValue(LV);
1892 = field->getType().isDestructedType()) {
1893 assert(LV.isSimple());
1901 if (ZeroInitPadding) {
1904 DoZeroInitPadding(PaddingStart, TotalSize,
nullptr);
1908void AggExprEmitter::DoZeroInitPadding(uint64_t &PaddingStart,
1909 uint64_t PaddingEnd,
1910 const FieldDecl *NextField) {
1918 llvm::Constant *SizeVal = Builder.getInt64((End - Start).getQuantity());
1922 if (NextField !=
nullptr && NextField->
isBitField()) {
1925 const CGRecordLayout &RL =
1929 if (StorageStart + Info.
StorageSize > PaddingStart) {
1930 if (StorageStart > PaddingStart)
1931 InitBytes(PaddingStart, StorageStart);
1944 if (PaddingStart < PaddingEnd)
1945 InitBytes(PaddingStart, PaddingEnd);
1946 if (NextField !=
nullptr)
1951void AggExprEmitter::VisitArrayInitLoopExpr(
const ArrayInitLoopExpr *E,
1952 llvm::Value *outerBegin) {
1954 CodeGenFunction::OpaqueValueMapping binding(CGF, E->
getCommonExpr());
1956 Address destPtr = EnsureSlot(E->
getType()).getAddress();
1963 llvm::Value *zero = llvm::ConstantInt::get(CGF.
SizeTy, 0);
1964 llvm::Value *indices[] = {zero, zero};
1965 llvm::Value *begin = Builder.CreateInBoundsGEP(destPtr.
getElementType(),
1967 indices,
"arrayinit.begin");
1973 ArrayInitLoopExpr *InnerLoop = dyn_cast<ArrayInitLoopExpr>(E->
getSubExpr());
1975 QualType elementType =
1978 CharUnits elementAlign =
1982 llvm::BasicBlock *entryBB = Builder.GetInsertBlock();
1987 llvm::PHINode *index =
1988 Builder.CreatePHI(zero->getType(), 2,
"arrayinit.index");
1989 index->addIncoming(zero, entryBB);
1990 llvm::Value *element =
1991 Builder.CreateInBoundsGEP(llvmElementType, begin, index);
1995 EHScopeStack::stable_iterator
cleanup;
1997 if (outerBegin->getType() != element->getType())
1998 outerBegin = Builder.CreateBitCast(outerBegin, element->getType());
2011 CodeGenFunction::RunCleanupsScope CleanupsScope(CGF);
2012 CodeGenFunction::ArrayInitLoopExprScope Scope(CGF, index);
2014 Address(element, llvmElementType, elementAlign), elementType);
2022 AggExprEmitter(CGF, elementSlot,
false)
2023 .VisitArrayInitLoopExpr(InnerLoop, outerBegin);
2025 EmitInitializationToLValue(E->
getSubExpr(), elementLV);
2029 llvm::Value *nextIndex = Builder.CreateNUWAdd(
2030 index, llvm::ConstantInt::get(CGF.
SizeTy, 1),
"arrayinit.next");
2031 index->addIncoming(nextIndex, Builder.GetInsertBlock());
2034 llvm::Value *done = Builder.CreateICmpEQ(
2035 nextIndex, llvm::ConstantInt::get(CGF.
SizeTy, numElements),
2038 Builder.CreateCondBr(done, endBB, bodyBB);
2047void AggExprEmitter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
2048 AggValueSlot Dest = EnsureSlot(E->
getType());
2051 EmitInitializationToLValue(E->
getBase(), DestLV);
2063 if (
auto *MTE = dyn_cast<MaterializeTemporaryExpr>(E))
2064 E = MTE->getSubExpr();
2074 ILE = dyn_cast<InitListExpr>(ILE->
getInit(0));
2082 if (!RT->isUnionType()) {
2086 unsigned ILEElement = 0;
2087 if (
auto *CXXRD = dyn_cast<CXXRecordDecl>(SD))
2088 while (ILEElement != CXXRD->getNumBases())
2091 for (
const auto *Field : SD->
fields()) {
2094 if (Field->getType()->isIncompleteArrayType() ||
2097 if (Field->isUnnamedBitField())
2103 if (Field->getType()->isReferenceType())
2110 return NumNonZeroBytes;
2116 for (
unsigned i = 0, e = ILE->
getNumInits(); i != e; ++i)
2118 return NumNonZeroBytes;
2137 if (RD->hasUserDeclaredConstructor())
2149 if (NumNonZeroBytes*4 > Size)
2153 llvm::Constant *SizeVal = CGF.
Builder.getInt64(Size.getQuantity());
2171 "Invalid aggregate expression to emit");
2173 "slot has bits but no address");
2178 AggExprEmitter(*
this, Slot, Slot.
isIgnored()).Visit(
const_cast<Expr*
>(E));
2195 return AggExprEmitter(*
this, Dest, Dest.
isIgnored())
2196 .EmitFinalDestCopy(
Type, Src, SrcKind);
2239 getContext().getASTRecordLayout(BaseRD).getSize() <=
2257 assert((
Record->hasTrivialCopyConstructor() ||
2258 Record->hasTrivialCopyAssignment() ||
2259 Record->hasTrivialMoveConstructor() ||
2260 Record->hasTrivialMoveAssignment() ||
2261 Record->hasAttr<TrivialABIAttr>() ||
Record->isUnion()) &&
2262 "Trying to aggregate-copy a type without a trivial copy/move "
2263 "constructor or assignment operator");
2272 if (
getTargetHooks().emitCUDADeviceBuiltinSurfaceDeviceCopy(*
this, Dest,
2276 if (
getTargetHooks().emitCUDADeviceBuiltinTextureDeviceCopy(*
this, Dest,
2302 llvm::Value *SizeVal =
nullptr;
2305 if (
auto *VAT = dyn_cast_or_null<VariableArrayType>(
2311 SizeVal =
Builder.CreateNUWMul(
2340 if (
Record->hasObjectMember()) {
2341 CGM.getObjCRuntime().EmitGCMemmoveCollectable(*
this, DestPtr, SrcPtr,
2347 if (
const auto *
Record = BaseType->getAsRecordDecl()) {
2348 if (
Record->hasObjectMember()) {
2349 CGM.getObjCRuntime().EmitGCMemmoveCollectable(*
this, DestPtr, SrcPtr,
2356 auto *Inst =
Builder.CreateMemCpy(DestPtr, SrcPtr, SizeVal, isVolatile);
2362 if (llvm::MDNode *TBAAStructTag =
CGM.getTBAAStructInfo(Ty))
2363 Inst->setMetadata(llvm::LLVMContext::MD_tbaa_struct, TBAAStructTag);
2365 if (
CGM.getCodeGenOpts().NewStructPathTBAA) {
2368 CGM.DecorateInstructionWithTBAA(Inst, TBAAInfo);
Defines the clang::ASTContext interface.
static CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF)
GetNumNonZeroBytesInInit - Get an approximate count of the number of non-zero bytes that will be stor...
static Expr * findPeephole(Expr *op, CastKind kind, const ASTContext &ctx)
Attempt to look through various unimportant expressions to find a cast of the given kind.
static bool isBlockVarRef(const Expr *E)
Is the value of the given expression possibly a reference to or into a __block variable?
static bool isSimpleZero(const Expr *E, CodeGenFunction &CGF)
isSimpleZero - If emitting this value will obviously just cause a store of zero to memory,...
static llvm::Value * EmitCompare(CGBuilderTy &Builder, CodeGenFunction &CGF, const BinaryOperator *E, llvm::Value *LHS, llvm::Value *RHS, CompareKind Kind, const char *NameSuffix="")
static void EmitHLSLElementwiseCast(CodeGenFunction &CGF, LValue DestVal, LValue SrcVal, SourceLocation Loc)
static bool castPreservesZero(const CastExpr *CE)
Determine whether the given cast kind is known to always convert values with all zero bits in their v...
static void CheckAggExprForMemSetUse(AggValueSlot &Slot, const Expr *E, CodeGenFunction &CGF)
CheckAggExprForMemSetUse - If the initializer is large and has a lot of zeros in it,...
static void EmitHLSLScalarElementwiseAndSplatCasts(CodeGenFunction &CGF, LValue DestVal, llvm::Value *SrcVal, QualType SrcTy, SourceLocation Loc)
static bool isTrivialFiller(Expr *e)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
llvm::MachO::Record Record
static bool isVector(QualType QT, QualType ElementType)
This helper function returns true if QT is a vector type that has element type ElementType.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
const ConstantArrayType * getAsConstantArrayType(QualType T) const
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
const ASTRecordLayout & getASTRecordLayout(const RecordDecl *D) const
Get or compute information about the layout of the specified record (struct/union/class) D,...
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
ComparisonCategories CompCategories
Types and expressions required to build C++2a three-way comparisons using operator<=>,...
QualType removeAddrSpaceQualType(QualType T) const
Remove any existing address space on the type and returns the type with qualifiers intact (or that's ...
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
const ArrayType * getAsArrayType(QualType T) const
Type Query functions.
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
static bool hasSameType(QualType T1, QualType T2)
Determine whether the given types T1 and T2 are equivalent.
QualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const
Return the uniqued reference to the type for an address space qualified type with the specified type ...
unsigned getTargetAddressSpace(LangAS AS) const
static bool hasSameUnqualifiedType(QualType T1, QualType T2)
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
uint64_t getFieldOffset(unsigned FieldNo) const
getFieldOffset - Get the offset of the given field index, in bits.
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
CharUnits getNonVirtualSize() const
getNonVirtualSize - Get the non-virtual size (in chars) of an object, which is the size of the object...
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
Expr * getCond() const
getCond - Return the expression representing the condition for the ?
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression representing the value of the expression if the condition eval...
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression representing the value of the expression if the condition eva...
llvm::APInt getArraySize() const
OpaqueValueExpr * getCommonExpr() const
Get the common subexpression shared by all initializations (the source array).
Expr * getSubExpr() const
Get the initializer to use for each array element.
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
QualType getElementType() const
A builtin binary operation expression such as "x + y" or "x <= y".
CXXTemporary * getTemporary()
const Expr * getSubExpr() const
Expr * getExpr()
Get the initialization expression that will be used.
bool constructsVBase() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will call.
bool inheritedFromVBase() const
Determine whether the inherited constructor is inherited from a virtual base of the object we constru...
MutableArrayRef< Expr * > getInitExprs()
FieldDecl * getInitializedFieldInUnion()
Represents a C++ struct/union/class.
bool isTriviallyCopyable() const
Determine whether this class is considered trivially copyable per (C++11 [class]p6).
bool isEmpty() const
Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).
Expr * getSemanticForm()
Get an equivalent semantic form for this expression.
QualType getCallReturnType(const ASTContext &Ctx) const
getCallReturnType - Get the return type of the call expr.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
CastKind getCastKind() const
CharUnits - This is an opaque type for sizes expressed in character units.
bool isZero() const
isZero - Test whether the quantity equals zero.
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
CharUnits alignmentOfArrayElement(CharUnits elementSize) const
Given that this is the alignment of the first element of an array, return the minimum alignment of an...
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
Expr * getChosenSubExpr() const
getChosenSubExpr - Return the subexpression chosen according to the condition.
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
llvm::Value * getBasePointer() const
llvm::Value * emitRawPointer(CodeGenFunction &CGF) const
Return the pointer contained in this class after authenticating it and adding offset to it if necessa...
CharUnits getAlignment() const
llvm::Type * getElementType() const
Return the type of the values stored in this address.
Address withElementType(llvm::Type *ElemTy) const
Return address with different element type, but same pointer and alignment.
void setVolatile(bool flag)
static AggValueSlot ignored()
ignored - Returns an aggregate value slot indicating that the aggregate value is being ignored.
Address getAddress() const
CharUnits getPreferredSize(ASTContext &Ctx, QualType Type) const
Get the preferred size to use when storing a value to this slot.
NeedsGCBarriers_t requiresGCollection() const
void setExternallyDestructed(bool destructed=true)
void setZeroed(bool V=true)
IsZeroed_t isZeroed() const
Qualifiers getQualifiers() const
static AggValueSlot forLValue(const LValue &LV, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
IsAliased_t isPotentiallyAliased() const
static AggValueSlot forAddr(Address addr, Qualifiers quals, IsDestructed_t isDestructed, NeedsGCBarriers_t needsGC, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed, IsSanitizerChecked_t isChecked=IsNotSanitizerChecked)
forAddr - Make a slot for an aggregate value.
IsDestructed_t isExternallyDestructed() const
Overlap_t mayOverlap() const
llvm::Value * emitRawPointer(CodeGenFunction &CGF) const
llvm::CallInst * CreateMemSet(Address Dest, llvm::Value *Value, llvm::Value *Size, bool IsVolatile=false)
Address CreateStructGEP(Address Addr, unsigned Index, const llvm::Twine &Name="")
virtual llvm::Value * EmitMemberPointerComparison(CodeGenFunction &CGF, llvm::Value *L, llvm::Value *R, const MemberPointerType *MPT, bool Inequality)
Emit a comparison between two member pointers. Returns an i1.
void emitInitListOpaqueValues(CodeGenFunction &CGF, InitListExpr *E)
virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, Address DestPtr, Address SrcPtr, llvm::Value *Size)=0
const CGBitFieldInfo & getBitFieldInfo(const FieldDecl *FD) const
Return the BitFieldInfo that corresponds to the field FD.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void CreateCoercedStore(llvm::Value *Src, Address Dst, llvm::TypeSize DstSize, bool DstIsVolatile)
Create a store to.
void EmitBranchOnBoolExpr(const Expr *Cond, llvm::BasicBlock *TrueBlock, llvm::BasicBlock *FalseBlock, uint64_t TrueCount, Stmt::Likelihood LH=Stmt::LH_None, const Expr *ConditionalOp=nullptr, const VarDecl *ConditionalDecl=nullptr)
EmitBranchOnBoolExpr - Emit a branch on a boolean condition (e.g.
RValue EmitObjCMessageExpr(const ObjCMessageExpr *E, ReturnValueSlot Return=ReturnValueSlot())
void EmitCXXConstructExpr(const CXXConstructExpr *E, AggValueSlot Dest)
AggValueSlot::Overlap_t getOverlapForFieldInit(const FieldDecl *FD)
Determine whether a field initialization may overlap some other object.
void callCStructMoveConstructor(LValue Dst, LValue Src)
void EmitNullInitialization(Address DestPtr, QualType Ty)
EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...
static bool hasScalarEvaluationKind(QualType T)
llvm::Type * ConvertType(QualType T)
void EmitAggFinalDestCopy(QualType Type, AggValueSlot Dest, const LValue &Src, ExprValueKind SrcKind)
EmitAggFinalDestCopy - Emit copy of the specified aggregate into destination address.
void pushRegularPartialArrayCleanup(llvm::Value *arrayBegin, llvm::Value *arrayEnd, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)
pushRegularPartialArrayCleanup - Push an EH cleanup to destroy already-constructed elements of the gi...
void EmitCXXThrowExpr(const CXXThrowExpr *E, bool KeepInsertionPoint=true)
void EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, llvm::Value **Result=nullptr)
EmitStoreThroughBitfieldLValue - Store Src into Dst with same constraints as EmitStoreThroughLValue.
bool hasVolatileMember(QualType T)
hasVolatileMember - returns true if aggregate type has a volatile member.
llvm::SmallVector< DeferredDeactivateCleanup > DeferredDeactivationCleanupStack
RValue EmitVAArg(VAArgExpr *VE, Address &VAListAddr, AggValueSlot Slot=AggValueSlot::ignored())
Generate code to get an argument from the passed in pointer and update it accordingly.
RValue EmitPseudoObjectRValue(const PseudoObjectExpr *e, AggValueSlot slot=AggValueSlot::ignored())
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
void addInstToCurrentSourceAtom(llvm::Instruction *KeyInstruction, llvm::Value *Backup)
See CGDebugInfo::addInstToCurrentSourceAtom.
AggValueSlot::Overlap_t getOverlapForBaseInit(const CXXRecordDecl *RD, const CXXRecordDecl *BaseRD, bool IsVirtual)
Determine whether a base class initialization may overlap some other object.
const LangOptions & getLangOpts() const
RValue EmitReferenceBindingToExpr(const Expr *E)
Emits a reference binding to the passed in expression.
LValue EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E)
void pushDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
pushDestroy - Push the standard destructor for the given type as at least a normal cleanup.
@ TCK_Store
Checking the destination of a store. Must be suitably sized and aligned.
@ TCK_Load
Checking the operand of a load. Must be suitably sized and aligned.
void pushIrregularPartialArrayCleanup(llvm::Value *arrayBegin, Address arrayEndPointer, QualType elementType, CharUnits elementAlignment, Destroyer *destroyer)
pushIrregularPartialArrayCleanup - Push a NormalAndEHCleanup to destroy already-constructed elements ...
Destroyer * getDestroyer(QualType::DestructionKind destructionKind)
LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e)
void EmitAggregateCopy(LValue Dest, LValue Src, QualType EltTy, AggValueSlot::Overlap_t MayOverlap, bool isVolatile=false)
EmitAggregateCopy - Emit an aggregate copy.
const TargetInfo & getTarget() const
void EmitIgnoredExpr(const Expr *E)
EmitIgnoredExpr - Emit an expression in a context which ignores the result.
RValue EmitCallExpr(const CallExpr *E, ReturnValueSlot ReturnValue=ReturnValueSlot(), llvm::CallBase **CallOrInvoke=nullptr)
RValue EmitLoadOfLValue(LValue V, SourceLocation Loc)
EmitLoadOfLValue - Given an expression that represents a value lvalue, this method emits the address ...
void pushDestroyAndDeferDeactivation(QualType::DestructionKind dtorKind, Address addr, QualType type)
void DeactivateCleanupBlock(EHScopeStack::stable_iterator Cleanup, llvm::Instruction *DominatingIP)
DeactivateCleanupBlock - Deactivates the given cleanup block.
void callCStructCopyAssignmentOperator(LValue Dst, LValue Src)
void pushFullExprCleanup(CleanupKind kind, As... A)
pushFullExprCleanup - Push a cleanup to be run at the end of the current full-expression.
LValue EmitAggExprToLValue(const Expr *E)
EmitAggExprToLValue - Emit the computation of the specified expression of aggregate type into a tempo...
RValue EmitCoyieldExpr(const CoyieldExpr &E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
AggValueSlot CreateAggTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)
CreateAggTemp - Create a temporary memory object for the given aggregate type.
llvm::Value * emitArrayLength(const ArrayType *arrayType, QualType &baseType, Address &addr)
emitArrayLength - Compute the length of an array, even if it's a VLA, and drill down to the base elem...
void callCStructCopyConstructor(LValue Dst, LValue Src)
bool HaveInsertPoint() const
HaveInsertPoint - True if an insertion point is defined.
RValue EmitAtomicLoad(LValue LV, SourceLocation SL, AggValueSlot Slot=AggValueSlot::ignored())
CGDebugInfo * getDebugInfo()
llvm::Value * getTypeSize(QualType Ty)
Returns calculated size of the specified type.
bool EmitLifetimeStart(llvm::Value *Addr)
Emit a lifetime.begin marker if some criteria are satisfied.
LValue EmitLValueForFieldInitialization(LValue Base, const FieldDecl *Field)
EmitLValueForFieldInitialization - Like EmitLValueForField, except that if the Field is a reference,...
Address GetAddressOfDirectBaseInCompleteClass(Address Value, const CXXRecordDecl *Derived, const CXXRecordDecl *Base, bool BaseIsVirtual)
GetAddressOfBaseOfCompleteClass - Convert the given pointer to a complete class to the given direct b...
llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)
CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...
LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its LValue mapping if it exists, otherwise create one.
const TargetCodeGenInfo & getTargetHooks() const
void EmitLifetimeEnd(llvm::Value *Addr)
RawAddress CreateMemTempWithoutCast(QualType T, const Twine &Name="tmp")
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen without...
void incrementProfileCounter(const Stmt *S, llvm::Value *StepV=nullptr)
Increment the profiler's counter for the given statement by StepV.
void callCStructMoveAssignmentOperator(LValue Dst, LValue Src)
ASTContext & getContext() const
void EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit=false)
EmitStoreThroughLValue - Store the specified rvalue into the specified lvalue, where both are guarant...
void pushLifetimeExtendedDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer, bool useEHCleanupForArray)
Address EmitCompoundStmt(const CompoundStmt &S, bool GetLast=false, AggValueSlot AVS=AggValueSlot::ignored())
EmitCompoundStmt - Emit a compound statement {..} node.
RValue EmitAnyExpr(const Expr *E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
EmitAnyExpr - Emit code to compute the specified expression which can have any type.
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind.
CleanupKind getCleanupKind(QualType::DestructionKind kind)
llvm::Type * ConvertTypeForMem(QualType T)
RValue EmitAtomicExpr(AtomicExpr *E)
CodeGenTypes & getTypes() const
void FlattenAccessAndTypeLValue(LValue LVal, SmallVectorImpl< LValue > &AccessList)
RValue EmitCoawaitExpr(const CoawaitExpr &E, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
void EmitCXXTemporary(const CXXTemporary *Temporary, QualType TempType, Address Ptr)
Emits all the code to cause the given temporary to be cleaned up.
bool LValueIsSuitableForInlineAtomic(LValue Src)
An LValue is a candidate for having its loads and stores be made atomic if we are operating under /vo...
LValue EmitCheckedLValue(const Expr *E, TypeCheckKind TCK)
Same as EmitLValue but additionally we generate checking code to guard against undefined behavior.
void EmitInheritedCXXConstructorCall(const CXXConstructorDecl *D, bool ForVirtualBase, Address This, bool InheritedFromVBase, const CXXInheritedCtorInitExpr *E)
Emit a call to a constructor inherited from a base class, passing the current constructor's arguments...
RawAddress CreateMemTemp(QualType T, const Twine &Name="tmp", RawAddress *Alloca=nullptr)
CreateMemTemp - Create a temporary memory object of the given type, with appropriate alignmen and cas...
void EmitInitializationToLValue(const Expr *E, LValue LV, AggValueSlot::IsZeroed_t IsZeroed=AggValueSlot::IsNotZeroed)
EmitInitializationToLValue - Emit an initializer to an LValue.
void EmitAggExpr(const Expr *E, AggValueSlot AS)
EmitAggExpr - Emit the computation of the specified expression of aggregate type.
static bool hasAggregateEvaluationKind(QualType T)
LValue MakeAddrLValue(Address Addr, QualType T, AlignmentSource Source=AlignmentSource::Type)
void EmitLambdaVLACapture(const VariableArrayType *VAT, LValue LV)
void EmitAtomicStore(RValue rvalue, LValue lvalue, bool isInit)
uint64_t getProfileCount(const Stmt *S)
Get the profiler's count for the given statement.
void ErrorUnsupported(const Stmt *S, const char *Type)
ErrorUnsupported - Print out an error that codegen doesn't support the specified stmt yet.
LValue EmitLValue(const Expr *E, KnownNonNull_t IsKnownNonNull=NotKnownNonNull)
EmitLValue - Emit code to compute a designator that specifies the location of the expression.
llvm::LLVMContext & getLLVMContext()
llvm::Value * EmitScalarConversion(llvm::Value *Src, QualType SrcTy, QualType DstTy, SourceLocation Loc)
Emit a conversion from the specified type to the specified destination type, both of which are LLVM s...
void EmitStoreOfScalar(llvm::Value *Value, Address Addr, bool Volatile, QualType Ty, AlignmentSource Source=AlignmentSource::Type, bool isInit=false, bool isNontemporal=false)
EmitStoreOfScalar - Store a scalar value to an address, taking care to appropriately convert from the...
llvm::Value * EmitDynamicCast(Address V, const CXXDynamicCastExpr *DCE)
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
void EmitExplicitCastExprType(const ExplicitCastExpr *E, CodeGenFunction *CGF=nullptr)
Emit type info if type of an expression is a variably modified type.
CGHLSLRuntime & getHLSLRuntime()
Return a reference to the configured HLSL runtime.
llvm::Module & getModule() const
bool isPaddedAtomicType(QualType type)
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
CGCXXABI & getCXXABI() const
ASTContext & getContext() const
bool shouldZeroInitPadding() const
CGObjCRuntime & getObjCRuntime()
Return a reference to the configured Objective-C runtime.
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
LangAS GetGlobalConstantAddressSpace() const
Return the AST address space of constant literal, which is used to emit the constant literal as globa...
bool isPointerZeroInitializable(QualType T)
Check if the pointer type can be zero-initialized (in the C++ sense) with an LLVM zeroinitializer.
const CGRecordLayout & getCGRecordLayout(const RecordDecl *)
getCGRecordLayout - Return record layout info for the given record decl.
bool isZeroInitializable(QualType T)
IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...
stable_iterator stable_begin() const
Create a stable reference to the top of the EH stack.
iterator find(stable_iterator save) const
Turn a stable reference to a scope depth into a unstable pointer to the EH stack.
LValue - This represents an lvalue references.
Address getAddress() const
TBAAAccessInfo getTBAAInfo() const
RValue - This trivial value class is used to represent the result of an expression that is evaluated.
llvm::Value * getAggregatePointer(QualType PointeeType, CodeGenFunction &CGF) const
static RValue get(llvm::Value *V)
static RValue getAggregate(Address addr, bool isVolatile=false)
Convert an Address to an RValue.
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
getComplexVal - Return the real/imag components of this complex value.
const ComparisonCategoryInfo & getInfoForType(QualType Ty) const
Return the comparison category information as specified by getCategoryForType(Ty).
bool isPartial() const
True iff the comparison is not totally ordered.
const ValueInfo * getLess() const
const ValueInfo * getUnordered() const
const CXXRecordDecl * Record
The declaration for the comparison category type from the standard library.
const ValueInfo * getGreater() const
const ValueInfo * getEqualOrEquiv() const
Complex values, per C99 6.2.5p11.
const Expr * getInitializer() const
llvm::APInt getSize() const
Return the constant array size as an APInt.
A reference to a declared variable, function, enum, etc.
InitListExpr * getUpdater() const
This represents one expression.
Expr * IgnoreParenNoopCasts(const ASTContext &Ctx) LLVM_READONLY
Skip past any parentheses and casts which do not change the value (including ptr->int casts of the sa...
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool HasSideEffects(const ASTContext &Ctx, bool IncludePossibleEffects=true) const
HasSideEffects - This routine returns true for all those expressions which have any effect other than...
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Represents a member of a struct/union/class.
bool isBitField() const
Determines whether this field is a bitfield.
unsigned getFieldIndex() const
Returns the index of this field within its record, as appropriate for passing to ASTRecordLayout::get...
const RecordDecl * getParent() const
Returns the parent of this field declaration, which is the struct in which this field is defined.
const Expr * getSubExpr() const
Describes an C or C++ initializer list.
bool isTransparent() const
Is this a transparent initializer list (that is, an InitListExpr that is purely syntactic,...
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
unsigned getNumInits() const
bool hadArrayRangeDesignator() const
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
const Expr * getInit(unsigned Init) const
ArrayRef< Expr * > inits()
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument for this lambda expression.
Expr *const * const_capture_init_iterator
Const iterator that walks over the capture initialization arguments.
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
CXXRecordDecl * getLambdaClass() const
Retrieve the class that corresponds to the lambda.
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
A pointer to member type per C++ 8.3.3 - Pointers to members.
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
Expr * getSelectedExpr() const
const Expr * getSubExpr() const
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isTriviallyCopyableType(const ASTContext &Context) const
Return true if this is a trivially copyable type (C++0x [basic.types]p9)
LangAS getAddressSpace() const
Return the address space of this type.
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
bool isPODType(const ASTContext &Context) const
Determine whether this is a Plain Old Data (POD) type (C++ 3.9p10).
@ PCK_Struct
The type is a struct containing a field whose type is neither PCK_Trivial nor PCK_VolatileTrivial.
Represents a struct/union/class.
bool hasObjectMember() const
field_range fields() const
specific_decl_iterator< FieldDecl > field_iterator
RecordDecl * getDefinitionOrSelf() const
field_iterator field_begin() const
Encodes a location in the source.
CompoundStmt * getSubStmt()
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Expr * getReplacement() const
uint64_t getPointerWidth(LangAS AddrSpace) const
Return the width of pointers on this target, for the specified address space.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isConstantArrayType() const
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
bool isPointerType() const
bool isReferenceType() const
bool isScalarType() const
bool isVariableArrayType() const
bool isCUDADeviceBuiltinSurfaceType() const
Check if the type is the CUDA device builtin surface type.
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
RecordDecl * castAsRecordDecl() const
bool isAnyComplexType() const
bool hasSignedIntegerRepresentation() const
Determine whether this type has an signed integer representation of some sort, e.g....
bool isMemberPointerType() const
bool isCUDADeviceBuiltinTextureType() const
Check if the type is the CUDA device builtin texture type.
bool hasFloatingRepresentation() const
Determine whether this type has a floating-point representation of some sort, e.g....
bool isVectorType() const
bool isRealFloatingType() const
Floating point categories.
const T * getAsCanonical() const
If this type is canonically the specified type, return its canonical type cast to that specified type...
const T * getAs() const
Member-template getAs<specific type>'.
bool isNullPtrType() const
bool isRecordType() const
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Expr * getSubExpr() const
Represents a variable declaration or definition.
Represents a GCC generic vector type.
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
@ EHCleanup
Denotes a cleanup that should run when a scope is exited using exceptional control flow (a throw stat...
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< AtomicType > atomicType
bool GE(InterpState &S, CodePtr OpPC)
The JSON file list parser is used to communicate input to InstallAPI.
bool isa(CodeGen::Address addr)
@ Result
The result type of a method or function.
const FunctionProtoType * T
LangAS
Defines the address space values used by the address space qualifier of QualType.
CastKind
CastKind - The kind of operation required for a conversion.
U cast(CodeGen::Address addr)
Diagnostic wrappers for TextAPI types for error reporting.
cl::opt< bool > EnableSingleByteCoverage
CharUnits StorageOffset
The offset of the bitfield storage from the start of the struct.
unsigned StorageSize
The storage size in bits which should be used when accessing this bitfield.
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
llvm::IntegerType * CharTy
char
llvm::IntegerType * SizeTy
llvm::PointerType * Int8PtrTy
llvm::IntegerType * PtrDiffTy
CharUnits getPointerAlign() const