18#include "mlir/IR/BuiltinAttributes.h"
19#include "mlir/IR/Value.h"
37 llvm::StringRef fieldName,
38 unsigned fieldIndex) {
41 "emitAddrOfFieldStorage: zero-sized field");
48 auto fieldPtr = cir::PointerType::get(fieldType);
52 cir::GetMemberOp memberAddr = builder.createGetMember(
53 loc, fieldPtr, base.
getPointer(), fieldName, fieldIndex);
61 layout.
getCIRType().getElementOffset(
cgm.getDataLayout().layout, idx));
70 assert(
expr->getType()->isPointerType() ||
71 expr->getType()->isObjCObjectPointerType());
75 if (
auto const *ce = dyn_cast<CastExpr>(
expr)) {
76 if (
const auto *ece = dyn_cast<ExplicitCastExpr>(ce))
77 cgm.emitExplicitCastExprType(ece);
79 switch (ce->getCastKind()) {
83 case CK_AddressSpaceConversion: {
84 if (
const auto *ptrTy =
85 ce->getSubExpr()->getType()->getAs<
PointerType>()) {
86 if (ptrTy->getPointeeType()->isVoidType())
94 *baseInfo = innerBaseInfo;
99 const QualType pointeeType =
expr->getType()->getPointeeType();
101 cgm.getNaturalTypeAlignment(pointeeType, &targetTypeBaseInfo);
114 const mlir::Type eltTy =
126 case CK_ArrayToPointerDecay:
129 case CK_UncheckedDerivedToBase:
130 case CK_DerivedToBase: {
135 ce->getSubExpr()->getType()->getPointeeCXXRecordDecl();
141 case CK_AnyPointerToBlockPointerCast:
142 case CK_BaseToDerived:
143 case CK_BaseToDerivedMemberPointer:
144 case CK_BlockPointerToObjCPointerCast:
145 case CK_BuiltinFnToFnPtr:
146 case CK_CPointerToObjCPointerCast:
147 case CK_DerivedToBaseMemberPointer:
149 case CK_FunctionToPointerDecay:
150 case CK_IntegralToPointer:
151 case CK_LValueToRValue:
152 case CK_LValueToRValueBitCast:
153 case CK_NullToMemberPointer:
154 case CK_NullToPointer:
155 case CK_ReinterpretMemberPointer:
161 case CK_ARCConsumeObject:
162 case CK_ARCExtendBlockObject:
163 case CK_ARCProduceObject:
164 case CK_ARCReclaimReturnedObject:
165 case CK_AtomicToNonAtomic:
166 case CK_BooleanToSignedIntegral:
167 case CK_ConstructorConversion:
168 case CK_CopyAndAutoreleaseBlockObject:
170 case CK_FixedPointCast:
171 case CK_FixedPointToBoolean:
172 case CK_FixedPointToFloating:
173 case CK_FixedPointToIntegral:
174 case CK_FloatingCast:
175 case CK_FloatingComplexCast:
176 case CK_FloatingComplexToBoolean:
177 case CK_FloatingComplexToIntegralComplex:
178 case CK_FloatingComplexToReal:
179 case CK_FloatingRealToComplex:
180 case CK_FloatingToBoolean:
181 case CK_FloatingToFixedPoint:
182 case CK_FloatingToIntegral:
183 case CK_HLSLAggregateSplatCast:
184 case CK_HLSLArrayRValue:
185 case CK_HLSLElementwiseCast:
186 case CK_HLSLVectorTruncation:
187 case CK_IntToOCLSampler:
188 case CK_IntegralCast:
189 case CK_IntegralComplexCast:
190 case CK_IntegralComplexToBoolean:
191 case CK_IntegralComplexToFloatingComplex:
192 case CK_IntegralComplexToReal:
193 case CK_IntegralRealToComplex:
194 case CK_IntegralToBoolean:
195 case CK_IntegralToFixedPoint:
196 case CK_IntegralToFloating:
197 case CK_LValueBitCast:
199 case CK_MemberPointerToBoolean:
200 case CK_NonAtomicToAtomic:
201 case CK_ObjCObjectLValueCast:
202 case CK_PointerToBoolean:
203 case CK_PointerToIntegral:
206 case CK_UserDefinedConversion:
208 case CK_ZeroToOCLOpaqueType:
209 llvm_unreachable(
"unexpected cast for emitPointerWithAlignment");
216 if (uo->getOpcode() == UO_AddrOf) {
226 if (
auto const *call = dyn_cast<CallExpr>(
expr)) {
227 switch (call->getBuiltinCallee()) {
230 case Builtin::BIaddressof:
231 case Builtin::BI__addressof:
232 case Builtin::BI__builtin_addressof: {
233 cgm.errorNYI(
expr->getSourceRange(),
234 "emitPointerWithAlignment: builtin addressof");
248 if (!dst.isSimple()) {
249 if (dst.isVectorElt()) {
251 const mlir::Location loc = dst.getVectorPointer().getLoc();
252 const mlir::Value vector =
253 builder.createLoad(loc, dst.getVectorAddress());
254 const mlir::Value newVector = builder.create<cir::VecInsertOp>(
255 loc, vector, src.
getValue(), dst.getVectorIdx());
256 builder.createStore(loc, newVector, dst.getVectorAddress());
260 assert(dst.isBitField() &&
"Unknown LValue type");
264 cgm.errorNYI(dst.getPointer().getLoc(),
265 "emitStoreThroughLValue: non-simple lvalue");
271 assert(src.
isScalar() &&
"Can't emit an aggregate store with this method");
283 "emitGlobalVarDeclLValue: thread_local variable");
297 if (realPtrTy != v.getType())
301 Address addr(v, realVarTy, alignment);
305 "emitGlobalVarDeclLValue: reference type");
314 bool isInit,
bool isNontemporal) {
319 if (clangVecTy->isExtVectorBoolType())
321 "emitStoreOfScalar ExtVectorBoolType");
329 if (vecTy.getSize() == 3 && !
getLangOpts().PreserveVec3Type)
331 "emitStoreOfScalar Vec3 & PreserveVec3Type disabled");
339 assert(addr.
getPointer() &&
"expected pointer to exist");
341 if (currVarDecl && srcAlloca) {
342 const VarDecl *vd = currVarDecl;
343 assert(vd &&
"VarDecl expected");
348 assert(
currSrcLoc &&
"must pass in source location");
349 builder.createStore(*
currSrcLoc, value, addr, isVolatile);
352 cgm.errorNYI(addr.
getPointer().getLoc(),
"emitStoreOfScalar nontemporal");
362 return targetInfo.
getABI().starts_with(
"aapcs");
370 Address ptr = dst.getBitFieldAddress();
372 bool useVoaltile =
cgm.getCodeGenOpts().AAPCSBitfieldWidth &&
373 dst.isVolatileQualified() &&
376 mlir::Value dstAddr = dst.getAddress().getPointer();
378 return builder.createSetBitfield(dstAddr.getLoc(), resLTy, ptr,
380 dst.isVolatileQualified(), useVoaltile);
402 mlir::Type fieldType,
405 cir::PointerType fieldPtr = cir::PointerType::get(fieldType);
411 rec.getElementOffset(
cgm.getDataLayout().layout,
index));
419 cgm.getTypes().getCIRGenRecordLayout(field->
getParent());
429 addr = builder.createElementBitCast(loc, addr, info.
storageType);
452 if (
auto *classDecl = dyn_cast<CXXRecordDecl>(rec)) {
453 if (
cgm.getCodeGenOpts().StrictVTablePointers &&
454 classDecl->isDynamicClass()) {
456 "emitLValueForField: strict vtable for dynamic class");
462 llvm::StringRef fieldName = field->
getName();
464 if (
cgm.lambdaFieldToName.count(field))
465 fieldName =
cgm.lambdaFieldToName[field];
471 cgm.getTypes().getCIRGenRecordLayout(field->
getParent());
492 if (field->
hasAttr<AnnotateAttr>()) {
503 "emitLValueForField: __weak attribute");
518 cgm.getTypes().getCIRGenRecordLayout(field->
getParent());
548 assert(0 &&
"NYI: emitStoreOfScalar constant matrix type");
553 lvalue.
getType(), isInit,
false);
563 if (clangVecTy->isExtVectorBoolType()) {
564 cgm.errorNYI(loc,
"emitLoadOfScalar: ExtVectorBoolType");
572 if (vecTy.getSize() == 3 && !
getLangOpts().PreserveVec3Type)
574 "emitLoadOfScalar Vec3 & PreserveVec3Type disabled");
580 cgm.errorNYI(
"emitLoadOfScalar: load atomic");
582 if (mlir::isa<cir::VoidType>(eltTy))
583 cgm.errorNYI(loc,
"emitLoadOfScalar: void type");
587 mlir::Value loadOp = builder.createLoad(
getLoc(loc), addr, isVolatile);
589 cgm.errorNYI(
"emitLoadOfScalar: boolean type with boolean representation");
616 const mlir::Value load =
622 cgm.errorNYI(loc,
"emitLoadOfLValue");
632 mlir::Value thisValue) {
640 mlir::Value thisValue) {
641 bool hasExplicitObjectParameter =
false;
642 const auto *methD = dyn_cast_if_present<CXXMethodDecl>(
curCodeDecl);
645 hasExplicitObjectParameter = methD->isExplicitObjectMemberFunction();
646 assert(methD->getParent()->isLambda());
647 assert(methD->getParent() == field->
getParent());
649 if (hasExplicitObjectParameter) {
672 mlir::Type fnTy = funcOp.getFunctionType();
673 mlir::Type ptrTy = cir::PointerType::get(fnTy);
674 mlir::Value addr = cgf.
getBuilder().create<cir::GetGlobalOp>(
675 loc, ptrTy, funcOp.getSymName());
679 ptrTy = cir::PointerType::get(fnTy);
681 addr = cir::CastOp::create(cgf.
getBuilder(), addr.getLoc(), ptrTy,
682 cir::CastKind::bitcast, addr);
729 case cir::GlobalLinkageKind::ExternalLinkage:
730 case cir::GlobalLinkageKind::LinkOnceODRLinkage:
731 case cir::GlobalLinkageKind::WeakODRLinkage:
732 case cir::GlobalLinkageKind::InternalLinkage:
733 case cir::GlobalLinkageKind::PrivateLinkage:
745 "should not emit an unevaluated operand");
747 if (
const auto *vd = dyn_cast<VarDecl>(nd)) {
749 if (vd->getStorageClass() ==
SC_Register && vd->hasAttr<AsmLabelAttr>() &&
750 !vd->isLocalVarDecl()) {
752 "emitDeclRefLValue: Global Named registers access");
757 (vd->getType()->isReferenceType() ||
765 vd = vd->getCanonicalDecl();
773 if (
const auto *vd = dyn_cast<VarDecl>(nd)) {
783 if (vd->hasLinkage() || vd->isStaticDataMember())
807 assert((vd->isStaticLocal() ||
symbolTable.count(vd)) &&
808 "non-static locals should be already mapped");
813 if (
const auto *bd = dyn_cast<BindingDecl>(nd)) {
822 if (
const auto *fd = dyn_cast<FunctionDecl>(nd)) {
826 if (
getContext().getTargetInfo().allowDebugInfoForExternalRef())
843 "evaluateExprAsBool: member pointer type");
859 if (op == UO_Extension)
865 assert(!t.
isNull() &&
"CodeGenFunction::EmitUnaryOpLValue: Illegal type");
885 assert(lv.
isSimple() &&
"real/imag on non-ordinary l-value");
900 ? builder.createComplexRealPtr(loc, lv.
getAddress())
901 : builder.createComplexImagPtr(loc, lv.
getAddress());
909 cir::UnaryOpKind kind =
910 e->
isIncrementOp() ? cir::UnaryOpKind::Inc : cir::UnaryOpKind::Dec;
913 assert(e->
isPrefix() &&
"Prefix operator in unexpected state!");
924 llvm_unreachable(
"UnaryOperator extension should be handled above!");
933 llvm_unreachable(
"UnaryOperator of non-lvalue kind!");
935 llvm_unreachable(
"Unknown unary operator kind!");
943 const auto *
castExpr = dyn_cast<CastExpr>(e);
957 if (
auto constantOp = idx.getDefiningOp<cir::ConstantOp>())
958 return constantOp.getValueAttr<cir::IntAttr>();
967 const CharUnits offset = constantIdx.getValue().getZExtValue() * eltSize;
984 mlir::Location beginLoc,
985 mlir::Location endLoc, mlir::Value ptr,
986 mlir::Type eltTy, mlir::Value idx,
997 mlir::Location beginLoc,
998 mlir::Location endLoc,
Address addr,
1000 mlir::Location loc,
bool shouldDecay) {
1015 const mlir::Value eltPtr =
1019 return Address(eltPtr, elementType, eltAlign);
1026 "emitArraySubscriptExpr: ExtVectorElementExpr");
1032 "emitArraySubscriptExpr: VariableArrayType");
1044 "index was neither LHS nor RHS");
1046 auto emitIdxAfterBase = [&](
bool promote) -> mlir::Value {
1050 auto ptrTy = mlir::dyn_cast<cir::PointerType>(idx.getType());
1051 if (promote && ptrTy && ptrTy.isPtrTo<cir::IntType>())
1053 "emitArraySubscriptExpr: index type cast");
1061 const mlir::Value idx = emitIdxAfterBase(
false);
1067 const mlir::Value idx = emitIdxAfterBase(
true);
1070 if (
const auto *ase = dyn_cast<ArraySubscriptExpr>(array))
1077 *
this,
cgm.getLoc(array->getBeginLoc()),
cgm.getLoc(array->getEndLoc()),
1092 "The base must be a pointer");
1112 cir::GlobalOp globalOp =
cgm.getGlobalForStringLiteral(e);
1113 assert(globalOp.getAlignment() &&
"expected alignment for string literal");
1114 unsigned align = *(globalOp.getAlignment());
1132 case CK_LValueToRValueBitCast:
1133 case CK_ArrayToPointerDecay:
1134 case CK_FunctionToPointerDecay:
1135 case CK_NullToMemberPointer:
1136 case CK_NullToPointer:
1137 case CK_IntegralToPointer:
1138 case CK_PointerToIntegral:
1139 case CK_PointerToBoolean:
1140 case CK_IntegralCast:
1141 case CK_BooleanToSignedIntegral:
1142 case CK_IntegralToBoolean:
1143 case CK_IntegralToFloating:
1144 case CK_FloatingToIntegral:
1145 case CK_FloatingToBoolean:
1146 case CK_FloatingCast:
1147 case CK_FloatingRealToComplex:
1148 case CK_FloatingComplexToReal:
1149 case CK_FloatingComplexToBoolean:
1150 case CK_FloatingComplexCast:
1151 case CK_FloatingComplexToIntegralComplex:
1152 case CK_IntegralRealToComplex:
1153 case CK_IntegralComplexToReal:
1154 case CK_IntegralComplexToBoolean:
1155 case CK_IntegralComplexCast:
1156 case CK_IntegralComplexToFloatingComplex:
1157 case CK_DerivedToBaseMemberPointer:
1158 case CK_BaseToDerivedMemberPointer:
1159 case CK_MemberPointerToBoolean:
1160 case CK_ReinterpretMemberPointer:
1161 case CK_AnyPointerToBlockPointerCast:
1162 case CK_ARCProduceObject:
1163 case CK_ARCConsumeObject:
1164 case CK_ARCReclaimReturnedObject:
1165 case CK_ARCExtendBlockObject:
1166 case CK_CopyAndAutoreleaseBlockObject:
1167 case CK_IntToOCLSampler:
1168 case CK_FloatingToFixedPoint:
1169 case CK_FixedPointToFloating:
1170 case CK_FixedPointCast:
1171 case CK_FixedPointToBoolean:
1172 case CK_FixedPointToIntegral:
1173 case CK_IntegralToFixedPoint:
1175 case CK_HLSLVectorTruncation:
1176 case CK_HLSLArrayRValue:
1177 case CK_HLSLElementwiseCast:
1178 case CK_HLSLAggregateSplatCast:
1179 llvm_unreachable(
"unexpected cast lvalue");
1182 llvm_unreachable(
"dependent cast kind in IR gen!");
1184 case CK_BuiltinFnToFnPtr:
1185 llvm_unreachable(
"builtin functions are handled elsewhere");
1188 case CK_NonAtomicToAtomic:
1189 case CK_AtomicToNonAtomic:
1192 case CK_BaseToDerived:
1193 case CK_AddressSpaceConversion:
1194 case CK_ObjCObjectLValueCast:
1195 case CK_VectorSplat:
1196 case CK_ConstructorConversion:
1197 case CK_UserDefinedConversion:
1198 case CK_CPointerToObjCPointerCast:
1199 case CK_BlockPointerToObjCPointerCast:
1200 case CK_LValueToRValue: {
1202 std::string(
"emitCastLValue for unhandled cast kind: ") +
1208 case CK_LValueBitCast: {
1212 cgm.emitExplicitCastExprType(ce,
this);
1227 "emitCastLValue: NoOp changes volatile qual");
1234 "emitCastLValue: NoOp needs bitcast");
1240 case CK_UncheckedDerivedToBase:
1241 case CK_DerivedToBase: {
1259 case CK_ZeroToOCLOpaqueType:
1260 llvm_unreachable(
"NULL to OpenCL opaque type lvalue cast is not valid");
1263 llvm_unreachable(
"Invalid cast kind");
1300 if (
auto *field = dyn_cast<FieldDecl>(nd)) {
1317 llvm_unreachable(
"Unhandled member declaration!");
1347 llvm_unreachable(
"bad evaluation kind");
1352 const Expr *inner) {
1363 cir::AllocaOp extDeclAlloca;
1367 extDeclAlloca = extDeclAddrIter->second.getDefiningOp<cir::AllocaOp>();
1369 mlir::OpBuilder::InsertPoint ip;
1371 ip = {extDeclAlloca->getBlock(), extDeclAlloca->getIterator()};
1380 "createReferenceTemporary: static/thread storage duration");
1385 llvm_unreachable(
"temporary can't have dynamic storage duration");
1387 llvm_unreachable(
"unknown storage duration");
1411 if (
const auto *classDecl =
1415 referenceTemporaryDtor = classDecl->getDestructor();
1417 if (!referenceTemporaryDtor)
1421 "storage duration with destructors");
1432 "pushTemporaryCleanup: automatic storage duration");
1436 llvm_unreachable(
"temporary cannot have dynamic storage duration");
1446 "Reference should never be pseudo-strong!");
1454 "emitMaterializeTemporaryExpr: ObjCLifetime");
1462 for (
const Expr *ignored : commaLHSs)
1467 "emitMaterializeTemporaryExpr: OpaqueValueExpr");
1474 if (
auto var =
object.getPointer().getDefiningOp<cir::GlobalOp>()) {
1487 if (!adjustments.empty()) {
1489 "emitMaterializeTemporaryExpr: Adjustments");
1504 assert(e->
isUnique() &&
"LValue for a nonunique OVE hasn't been emitted");
1516 assert(e->
isUnique() &&
"RValue for a nonunique OVE hasn't been emitted");
1528 "emitCompoundLiteralLValue: VariablyModifiedType");
1533 ".compoundliteral");
1544 "emitCompoundLiteralLValue: non C++ DestructedType");
1560 "Can't have a scalar return unless the return type is a "
1578 assert(e->
getOpcode() == BO_Assign &&
"unexpected binary l-value");
1617 llvm_unreachable(
"bad evaluation kind");
1636 llvm_unreachable(
"bad evaluation kind");
1644 if (!pd->isInlineBuiltinDeclaration())
1649CIRGenCallee CIRGenFunction::emitDirectCallee(
const GlobalDecl &gd) {
1652 if (
unsigned builtinID = fd->getBuiltinID()) {
1653 if (fd->getAttr<AsmLabelAttr>()) {
1654 cgm.errorNYI(
"AsmLabelAttr");
1657 StringRef ident = fd->getName();
1658 std::string fdInlineName = (ident +
".inline").str();
1660 bool isPredefinedLibFunction =
1661 cgm.getASTContext().BuiltinInfo.isPredefinedLibFunction(builtinID);
1663 bool hasAttributeNoBuiltin =
true;
1670 cgm.errorNYI(
"Inline only builtin function calls");
1679 else if (!isPredefinedLibFunction || !hasAttributeNoBuiltin)
1694 cgm.errorNYI(
"unsupported type for undef rvalue");
1705 "Callee must have function pointer type!");
1726 cgm.getTypes().arrangeFreeFunctionCall(args, fnType);
1748 calleeTy = cir::FuncType::get(calleeTy.getInputs(),
1749 calleeTy.getReturnType(),
false);
1750 auto calleePtrTy = cir::PointerType::get(calleeTy);
1754 if (
auto funcOp = mlir::dyn_cast<cir::FuncOp>(fn)) {
1755 addr = builder.create<cir::GetGlobalOp>(
1757 cir::PointerType::get(funcOp.getFunctionType()), funcOp.getSymName());
1759 addr = fn->getResult(0);
1762 fn = builder.createBitcast(addr, calleePtrTy).getDefiningOp();
1770 cir::CIRCallOpInterface callOp;
1783 if (
const auto *implicitCast = dyn_cast<ImplicitCastExpr>(e)) {
1784 if (implicitCast->getCastKind() == CK_FunctionToPointerDecay ||
1785 implicitCast->getCastKind() == CK_BuiltinFnToFnPtr) {
1786 return emitCallee(implicitCast->getSubExpr());
1791 assert(implicitCast->getCastKind() == CK_LValueToRValue &&
1792 "unexpected implicit cast on function pointers");
1793 }
else if (
const auto *declRef = dyn_cast<DeclRefExpr>(e)) {
1796 return emitDirectCallee(funcDecl);
1799 "emitCallee: call to member function is NYI");
1801 }
else if (
auto *pde = dyn_cast<CXXPseudoDestructorExpr>(e)) {
1806 mlir::Value calleePtr;
1818 if (
const auto *vd =
1823 CIRGenCallee callee(calleeInfo, calleePtr.getDefiningOp());
1831 if (
const auto *ce = dyn_cast<CXXMemberCallExpr>(e))
1839 if (
const auto *operatorCall = dyn_cast<CXXOperatorCallExpr>(e)) {
1843 dyn_cast_or_null<CXXMethodDecl>(operatorCall->getCalleeDecl()))
1878 "Array to pointer decay must have array source type!");
1886 auto lvalueAddrTy = mlir::cast<cir::PointerType>(addr.
getPointer().getType());
1891 [[maybe_unused]]
auto pointeeTy =
1892 mlir::cast<cir::ArrayType>(lvalueAddrTy.getPointee());
1895 assert(mlir::isa<cir::ArrayType>(arrayTy) &&
"expected array");
1896 assert(pointeeTy == arrayTy);
1906 mlir::Value ptr = builder.maybeBuildArrayDecay(
1918 cgm.errorNYI(loc,
"convertTempToRValue: complex type");
1921 cgm.errorNYI(loc,
"convertTempToRValue: aggregate type");
1926 llvm_unreachable(
"bad evaluation kind");
1933 const Stmt *elseS) {
1935 std::optional<mlir::Location> elseLoc;
1939 mlir::LogicalResult resThen = mlir::success(), resElse = mlir::success();
1942 [&](mlir::OpBuilder &, mlir::Location) {
1943 LexicalScope lexScope{*
this, thenLoc, builder.getInsertionBlock()};
1948 [&](mlir::OpBuilder &, mlir::Location) {
1949 assert(elseLoc &&
"Invalid location for elseS.");
1950 LexicalScope lexScope{*
this, *elseLoc, builder.getInsertionBlock()};
1955 return mlir::LogicalResult::success(resThen.succeeded() &&
1956 resElse.succeeded());
1964 std::optional<mlir::Location> elseLoc) {
1970 ifLocs.push_back(*elseLoc);
1971 mlir::Location loc = mlir::FusedLoc::get(&
getMLIRContext(), ifLocs);
1975 return builder.create<cir::IfOp>(loc, condV, elseLoc.has_value(),
1994 Expr *trueExpr = condOp->getTrueExpr();
1995 Expr *falseExpr = condOp->getFalseExpr();
1998 mlir::Value ternaryOpRes =
2000 .create<cir::TernaryOp>(
2002 [
this, trueExpr](mlir::OpBuilder &
b, mlir::Location loc) {
2004 b.create<cir::YieldOp>(loc, lhs);
2007 [
this, falseExpr](mlir::OpBuilder &
b, mlir::Location loc) {
2009 b.create<cir::YieldOp>(loc, rhs);
2018 cgm.errorNYI(
"NYI");
2032 mlir::Location loc,
CharUnits alignment,
2033 bool insertIntoFnEntryBlock,
2034 mlir::Value arraySize) {
2035 mlir::Block *entryBlock = insertIntoFnEntryBlock
2050 mlir::Location loc,
CharUnits alignment,
2051 mlir::OpBuilder::InsertPoint ip,
2052 mlir::Value arraySize) {
2057 cir::PointerType localVarPtrTy = builder.
getPointerTo(ty);
2058 mlir::IntegerAttr alignIntAttr =
cgm.
getSize(alignment);
2062 mlir::OpBuilder::InsertionGuard guard(builder);
2063 builder.restoreInsertionPoint(ip);
2065 ty, name, alignIntAttr);
2079 "emitCXXMemberCallExpr: C++ binary operator");
2086 if (md->isStatic()) {
2091 bool hasQualifier = me->hasQualifier();
2093 bool isArrow = me->isArrow();
2094 const Expr *base = me->getBase();
2097 ce, md,
returnValue, hasQualifier, qualifier, isArrow, base);
2102 assert(!dest.
isIgnored() &&
"Must have a destination!");
2119 "emitCXXConstructExpr: base requires initialization");
2149 bool forVirtualBase =
false;
2150 bool delegating =
false;
2162 forVirtualBase =
true;
2187 cgm.errorNYI(loc,
"load of volatile reference");
2190 builder.create<cir::LoadOp>(loc, refLVal.
getAddress().getElementType(),
2196 CharUnits align =
cgm.getNaturalTypeAlignment(pointeeType, pointeeBaseInfo);
2213 cir::TrapOp::create(builder, loc);
2215 builder.createBlock(builder.getBlock()->getParent());
2219 bool createNewBlock) {
2221 cir::UnreachableOp::create(builder,
getLoc(loc));
2223 builder.createBlock(builder.getBlock()->getParent());
2230 return builder.createDummyValue(loc, t, alignment);
2238 const Twine &name,
Address *alloca,
2239 mlir::OpBuilder::InsertPoint ip) {
2246 mlir::Location loc,
const Twine &name,
2248 mlir::OpBuilder::InsertPoint ip) {
2250 nullptr, alloca, ip);
2253 cgm.errorNYI(loc,
"temporary matrix value");
2261 mlir::Type ty,
CharUnits align, mlir::Location loc,
const Twine &name,
2262 mlir::Value arraySize, mlir::OpBuilder::InsertPoint ip) {
2263 cir::AllocaOp alloca = ip.isSet()
2266 alloca.setAlignmentAttr(
cgm.getSize(align));
2267 return Address(alloca, ty, align);
2273 mlir::Location loc,
const Twine &name,
2274 mlir::Value arraySize,
2276 mlir::OpBuilder::InsertPoint ip) {
2280 *allocaAddr = alloca;
2296 mlir::Value arraySize,
2297 bool insertIntoFnEntryBlock) {
2299 insertIntoFnEntryBlock, arraySize)
2307 mlir::OpBuilder::InsertPoint ip,
2308 mlir::Value arraySize) {
2309 assert(ip.isSet() &&
"Insertion point is not set");
2310 return mlir::cast<cir::AllocaOp>(
2351 mlir::TypedAttr cstToEmit = mlir::dyn_cast_if_present<mlir::TypedAttr>(
c);
2352 assert(cstToEmit &&
"expected a typed attribute");
2368 assert(constant &&
"not a constant");
2380 if (!
cgm.getLangOpts().MSVolatile)
2383 cgm.errorNYI(
"LValueSuitableForInlineAtomic LangOpts MSVolatile");
llvm::function_ref< void(mlir::OpBuilder &, mlir::Location)> BuilderCallbackRef
static Address createReferenceTemporary(CIRGenFunction &cgf, const MaterializeTemporaryExpr *m, const Expr *inner)
static bool isAAPCS(const TargetInfo &targetInfo)
Helper method to check if the underlying ABI is AAPCS.
static LValue emitFunctionDeclLValue(CIRGenFunction &cgf, const Expr *e, GlobalDecl gd)
static CharUnits getArrayElementAlign(CharUnits arrayAlign, mlir::Value idx, CharUnits eltSize)
static void pushTemporaryCleanup(CIRGenFunction &cgf, const MaterializeTemporaryExpr *m, const Expr *e, Address referenceTemporary)
static cir::IntAttr getConstantIndexOrNull(mlir::Value idx)
static const Expr * getSimpleArrayDecayOperand(const Expr *e)
If the specified expr is a simple decay from an array to pointer, return the array subexpression.
static QualType getFixedSizeElementType(const ASTContext &astContext, const VariableArrayType *vla)
static bool canEmitSpuriousReferenceToVariable(CIRGenFunction &cgf, const DeclRefExpr *e, const VarDecl *vd)
Determine whether we can emit a reference to vd from the current context, despite not necessarily hav...
static DeclRefExpr * tryToConvertMemberExprToDeclRefExpr(CIRGenFunction &cgf, const MemberExpr *me)
static cir::FuncOp emitFunctionDeclPointer(CIRGenModule &cgm, GlobalDecl gd)
static LValue emitGlobalVarDeclLValue(CIRGenFunction &cgf, const Expr *e, const VarDecl *vd)
static mlir::Value emitArraySubscriptPtr(CIRGenFunction &cgf, mlir::Location beginLoc, mlir::Location endLoc, mlir::Value ptr, mlir::Type eltTy, mlir::Value idx, bool shouldDecay)
static LValue emitCapturedFieldLValue(CIRGenFunction &cgf, const FieldDecl *fd, mlir::Value thisValue)
static bool onlyHasInlineBuiltinDeclaration(const FunctionDecl *fd)
Defines the clang::Expr interface and subclasses for C++ expressions.
__device__ __2f16 float c
static OpBuilder::InsertPoint getBestAllocaInsertPoint(mlir::Block *block)
cir::GetMemberOp createGetMember(mlir::Location loc, mlir::Type resultTy, mlir::Value base, llvm::StringRef name, unsigned index)
cir::PointerType getPointerTo(mlir::Type ty)
mlir::Value createBitcast(mlir::Value src, mlir::Type newTy)
mlir::Value createAlloca(mlir::Location loc, cir::PointerType addrType, mlir::Type type, llvm::StringRef name, mlir::IntegerAttr alignment, mlir::Value dynAllocSize)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
const VariableArrayType * getAsVariableArrayType(QualType T) const
CanQualType getCanonicalTagType(const TagDecl *TD) const
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
SourceLocation getExprLoc() const LLVM_READONLY
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
SourceLocation getBeginLoc() const LLVM_READONLY
SourceLocation getEndLoc() const
Represents an array type, per C99 6.7.5.2 - Array Declarators.
QualType getElementType() const
A builtin binary operation expression such as "x + y" or "x <= y".
mlir::Value getPointer() const
mlir::Type getElementType() const
Address withElementType(CIRGenBuilderTy &builder, mlir::Type ElemTy) const
Return address with different element type, a bitcast pointer, and the same alignment.
clang::CharUnits getAlignment() const
mlir::Type getType() const
mlir::Operation * getDefiningOp() const
Get the operation which defines this address.
IsZeroed_t isZeroed() const
static AggValueSlot forAddr(Address addr, clang::Qualifiers quals, IsDestructed_t isDestructed, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed)
Address getAddress() const
Address createElementBitCast(mlir::Location loc, Address addr, mlir::Type destType)
Cast the element type of the given address to a different type, preserving information like the align...
mlir::Value getArrayElement(mlir::Location arrayLocBegin, mlir::Location arrayLocEnd, mlir::Value arrayPtr, mlir::Type eltTy, mlir::Value idx, bool shouldDecay)
Create a cir.ptr_stride operation to get access to an array element.
Abstract information about a function or function prototype.
bool isPseudoDestructor() const
void setFunctionPointer(mlir::Operation *functionPtr)
const clang::FunctionDecl * getBuiltinDecl() const
const CXXPseudoDestructorExpr * getPseudoDestructorExpr() const
static CIRGenCallee forDirect(mlir::Operation *funcPtr, const CIRGenCalleeInfo &abstractInfo=CIRGenCalleeInfo())
unsigned getBuiltinID() const
static CIRGenCallee forBuiltin(unsigned builtinID, const clang::FunctionDecl *builtinDecl)
mlir::Operation * getFunctionPointer() const
static CIRGenCallee forPseudoDestructor(const clang::CXXPseudoDestructorExpr *expr)
static ConstantEmission forValue(mlir::TypedAttr c)
mlir::TypedAttr getValue() const
static bool shouldBindAsLValue(const Expr *expr)
mlir::Value emitComplexToScalarConversion(mlir::Value src, QualType srcTy, QualType dstTy, SourceLocation loc)
Emit a conversion from the specified complex type to the specified destination type,...
void emitCallArgs(CallArgList &args, PrototypeWrapper prototype, llvm::iterator_range< clang::CallExpr::const_arg_iterator > argRange, AbstractCallee callee=AbstractCallee(), unsigned paramsToSkip=0)
mlir::Type convertType(clang::QualType t)
static cir::TypeEvaluationKind getEvaluationKind(clang::QualType type)
Return the cir::TypeEvaluationKind of QualType type.
clang::GlobalDecl curGD
The GlobalDecl for the current function being compiled or the global variable currently being initial...
RValue convertTempToRValue(Address addr, clang::QualType type, clang::SourceLocation loc)
Given the address of a temporary variable, produce an r-value of its type.
CIRGenTypes & getTypes() const
Address emitPointerWithAlignment(const clang::Expr *expr, LValueBaseInfo *baseInfo=nullptr)
Given an expression with a pointer type, emit the value and compute our best estimate of the alignmen...
RValue emitLoadOfLValue(LValue lv, SourceLocation loc)
Given an expression that represents a value lvalue, this method emits the address of the lvalue,...
const clang::LangOptions & getLangOpts() const
cir::AllocaOp createTempAlloca(mlir::Type ty, mlir::Location loc, const Twine &name="tmp", mlir::Value arraySize=nullptr, bool insertIntoFnEntryBlock=false)
This creates an alloca and inserts it into the entry block if ArraySize is nullptr,...
void emitTrap(mlir::Location loc, bool createNewBlock)
Emit a trap instruction, which is used to abort the program in an abnormal way, usually for debugging...
mlir::Block * getCurFunctionEntryBlock()
RValue emitCXXMemberCallExpr(const clang::CXXMemberCallExpr *e, ReturnValueSlot returnValue)
LValue emitLValueForBitField(LValue base, const FieldDecl *field)
mlir::LogicalResult emitIfOnBoolExpr(const clang::Expr *cond, const clang::Stmt *thenS, const clang::Stmt *elseS)
Emit an if on a boolean condition to the specified blocks.
mlir::Value emitComplexExpr(const Expr *e)
Emit the computation of the specified expression of complex type, returning the result.
LValue makeNaturalAlignPointeeAddrLValue(mlir::Value v, clang::QualType t)
Given a value of type T* that may not be to a complete object, construct an l-vlaue withi the natural...
RValue emitCallExpr(const clang::CallExpr *e, ReturnValueSlot returnValue=ReturnValueSlot())
LValue emitMemberExpr(const MemberExpr *e)
LValue emitLValue(const clang::Expr *e)
Emit code to compute a designator that specifies the location of the expression.
Address makeNaturalAddressForPointer(mlir::Value ptr, QualType t, CharUnits alignment, bool forPointeeType=false, LValueBaseInfo *baseInfo=nullptr)
Construct an address with the natural alignment of T.
LValue emitLValueForLambdaField(const FieldDecl *field)
mlir::Value evaluateExprAsBool(const clang::Expr *e)
Perform the usual unary conversions on the specified expression and compare the result against zero,...
std::string getCounterRefTmpAsString()
LValue makeNaturalAlignAddrLValue(mlir::Value val, QualType ty)
void emitStoreOfScalar(mlir::Value value, Address addr, bool isVolatile, clang::QualType ty, bool isInit=false, bool isNontemporal=false)
mlir::Location getLoc(clang::SourceLocation srcLoc)
Helpers to convert Clang's SourceLocation to a MLIR Location.
mlir::Value emitOpOnBoolExpr(mlir::Location loc, const clang::Expr *cond)
TODO(cir): see EmitBranchOnBoolExpr for extra ideas).
Address getAddressOfBaseClass(Address value, const CXXRecordDecl *derived, llvm::iterator_range< CastExpr::path_const_iterator > path, bool nullCheckValue, SourceLocation loc)
LValue emitStringLiteralLValue(const StringLiteral *e)
LValue emitLoadOfReferenceLValue(Address refAddr, mlir::Location loc, QualType refTy, AlignmentSource source)
mlir::Value emitScalarPrePostIncDec(const UnaryOperator *e, LValue lv, cir::UnaryOpKind kind, bool isPre)
void emitAnyExprToMem(const Expr *e, Address location, Qualifiers quals, bool isInitializer)
Emits the code necessary to evaluate an arbitrary expression into the given memory location.
LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its LValue mapping if it exists, otherwise create one.
void emitNullInitialization(mlir::Location loc, Address destPtr, QualType ty)
RValue emitReferenceBindingToExpr(const Expr *e)
Emits a reference binding to the passed in expression.
RValue emitAnyExpr(const clang::Expr *e, AggValueSlot aggSlot=AggValueSlot::ignored())
Emit code to compute the specified expression which can have any type.
LValue emitArraySubscriptExpr(const clang::ArraySubscriptExpr *e)
mlir::Value emitScalarConversion(mlir::Value src, clang::QualType srcType, clang::QualType dstType, clang::SourceLocation loc)
Emit a conversion from the specified type to the specified destination type, both of which are CIR sc...
AggValueSlot createAggTemp(QualType ty, mlir::Location loc, const Twine &name="tmp", Address *alloca=nullptr)
Create a temporary memory object for the given aggregate type.
mlir::Type convertTypeForMem(QualType t)
mlir::Value emitAlloca(llvm::StringRef name, mlir::Type ty, mlir::Location loc, clang::CharUnits alignment, bool insertIntoFnEntryBlock, mlir::Value arraySize=nullptr)
void emitUnreachable(clang::SourceLocation loc, bool createNewBlock)
Emit a reached-unreachable diagnostic if loc is valid and runtime checking is enabled.
mlir::Value createDummyValue(mlir::Location loc, clang::QualType qt)
void emitCXXConstructExpr(const clang::CXXConstructExpr *e, AggValueSlot dest)
static Destroyer destroyCXXObject
RValue getUndefRValue(clang::QualType ty)
Get an appropriate 'undef' rvalue for the given type.
Address returnValue
The temporary alloca to hold the return value.
void emitCXXConstructorCall(const clang::CXXConstructorDecl *d, clang::CXXCtorType type, bool forVirtualBase, bool delegating, AggValueSlot thisAVS, const clang::CXXConstructExpr *e)
mlir::Value emitComplexPrePostIncDec(const UnaryOperator *e, LValue lv, cir::UnaryOpKind op, bool isPre)
std::string getCounterAggTmpAsString()
LValue emitUnaryOpLValue(const clang::UnaryOperator *e)
RValue emitLoadOfBitfieldLValue(LValue lv, SourceLocation loc)
RValue emitCall(const CIRGenFunctionInfo &funcInfo, const CIRGenCallee &callee, ReturnValueSlot returnValue, const CallArgList &args, cir::CIRCallOpInterface *callOp, mlir::Location loc)
LValue emitComplexAssignmentLValue(const BinaryOperator *e)
const clang::Decl * curCodeDecl
This is the inner-most code context, which includes blocks.
LValue emitLValueForFieldInitialization(LValue base, const clang::FieldDecl *field, llvm::StringRef fieldName)
Like emitLValueForField, excpet that if the Field is a reference, this will return the address of the...
LValue emitCallExprLValue(const clang::CallExpr *e)
mlir::Value emitScalarExpr(const clang::Expr *e)
Emit the computation of the specified expression of scalar type.
mlir::Value emitToMemory(mlir::Value value, clang::QualType ty)
Given a value and its clang type, returns the value casted to its memory representation.
LValue emitLValueForField(LValue base, const clang::FieldDecl *field)
cir::FuncOp curFn
The function for which code is currently being generated.
void pushDestroy(CleanupKind kind, Address addr, QualType type, Destroyer *destroyer)
Address emitLoadOfReference(LValue refLVal, mlir::Location loc, LValueBaseInfo *pointeeBaseInfo)
bool shouldNullCheckClassCastValue(const CastExpr *ce)
CIRGenBuilderTy & getBuilder()
LValue emitBinaryOperatorLValue(const BinaryOperator *e)
Address getAddrOfBitFieldStorage(LValue base, const clang::FieldDecl *field, mlir::Type fieldType, unsigned index)
CIRGenModule & getCIRGenModule()
mlir::MLIRContext & getMLIRContext()
LValue emitCastLValue(const CastExpr *e)
Casts are never lvalues unless that cast is to a reference type.
mlir::Value emitLoadOfScalar(LValue lvalue, SourceLocation loc)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
DeclMapTy localDeclMap
This keeps track of the CIR allocas or globals for local C declarations.
LValue emitDeclRefLValue(const clang::DeclRefExpr *e)
void emitComplexExprIntoLValue(const Expr *e, LValue dest, bool isInit)
llvm::DenseMap< const clang::ValueDecl *, clang::FieldDecl * > lambdaCaptureFields
ConstantEmission tryEmitAsConstant(const DeclRefExpr *refExpr)
Try to emit a reference to the given value without producing it as an l-value.
LValue makeAddrLValue(Address addr, QualType ty, AlignmentSource source=AlignmentSource::Type)
llvm::DenseMap< const OpaqueValueExpr *, RValue > opaqueRValues
Address emitArrayToPointerDecay(const Expr *e, LValueBaseInfo *baseInfo=nullptr)
void emitCXXAggrConstructorCall(const CXXConstructorDecl *ctor, const clang::ArrayType *arrayType, Address arrayBegin, const CXXConstructExpr *e, bool newPointerIsChecked, bool zeroInitialize=false)
Emit a loop to call a particular constructor for each of several members of an array.
LexicalScope * curLexScope
mlir::Value emitStoreThroughBitfieldLValue(RValue src, LValue dstresult)
llvm::DenseMap< const OpaqueValueExpr *, LValue > opaqueLValues
Keeps track of the current set of opaque value expressions.
std::optional< mlir::Location > currSrcLoc
Use to track source locations across nested visitor traversals.
LValue emitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *e)
clang::ASTContext & getContext() const
RValue emitCXXMemberOrOperatorMemberCallExpr(const clang::CallExpr *ce, const clang::CXXMethodDecl *md, ReturnValueSlot returnValue, bool hasQualifier, clang::NestedNameSpecifier qualifier, bool isArrow, const clang::Expr *base)
mlir::Value emitScalarConstant(const ConstantEmission &constant, Expr *e)
RValue emitBuiltinExpr(const clang::GlobalDecl &gd, unsigned builtinID, const clang::CallExpr *e, ReturnValueSlot returnValue)
RValue emitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *e, const CXXMethodDecl *md, ReturnValueSlot returnValue)
void emitStoreThroughLValue(RValue src, LValue dst, bool isInit=false)
Store the specified rvalue into the specified lvalue, where both are guaranteed to the have the same ...
mlir::Value cxxabiThisValue
bool isLValueSuitableForInlineAtomic(LValue lv)
An LValue is a candidate for having its loads and stores be made atomic if we are operating under /vo...
mlir::LogicalResult emitStmt(const clang::Stmt *s, bool useCurrentScope, llvm::ArrayRef< const Attr * > attrs={})
RValue getOrCreateOpaqueRValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its RValue mapping if it exists, otherwise create one.
Address createTempAllocaWithoutCast(mlir::Type ty, CharUnits align, mlir::Location loc, const Twine &name="tmp", mlir::Value arraySize=nullptr, mlir::OpBuilder::InsertPoint ip={})
This creates a alloca and inserts it into the entry block of the current region.
void emitIgnoredExpr(const clang::Expr *e)
Emit code to compute the specified expression, ignoring the result.
Address createMemTemp(QualType t, mlir::Location loc, const Twine &name="tmp", Address *alloca=nullptr, mlir::OpBuilder::InsertPoint ip={})
Create a temporary memory object of the given type, with appropriate alignmen and cast it to the defa...
void emitAggExpr(const clang::Expr *e, AggValueSlot slot)
RValue emitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *expr)
LValue emitCompoundLiteralLValue(const CompoundLiteralExpr *e)
CIRGenCallee emitCallee(const clang::Expr *e)
Address emitAddrOfFieldStorage(Address base, const FieldDecl *field, llvm::StringRef fieldName, unsigned fieldIndex)
Get the address of a zero-sized field within a record.
This class organizes the cross-function state that is used while generating CIR code.
DiagnosticBuilder errorNYI(SourceLocation, llvm::StringRef)
Helpers to emit "not yet implemented" error diagnostics.
mlir::IntegerAttr getSize(CharUnits size)
CIRGenBuilderTy & getBuilder()
cir::FuncOp getAddrOfFunction(clang::GlobalDecl gd, mlir::Type funcType=nullptr, bool forVTable=false, bool dontDefer=false, ForDefinition_t isForDefinition=NotForDefinition)
Return the address of the given function.
mlir::Value getAddrOfGlobalVar(const VarDecl *d, mlir::Type ty={}, ForDefinition_t isForDefinition=NotForDefinition)
Return the mlir::Value for the address of the given global variable.
cir::GlobalLinkageKind getCIRLinkageVarDefinition(const VarDecl *vd, bool isConstant)
This class handles record and union layout info while lowering AST types to CIR types.
cir::RecordType getCIRType() const
Return the "complete object" LLVM type associated with this record.
const CIRGenBitFieldInfo & getBitFieldInfo(const clang::FieldDecl *fd) const
Return the BitFieldInfo that corresponds to the field FD.
unsigned getCIRFieldNo(const clang::FieldDecl *fd) const
Return cir::RecordType element number that corresponds to the field FD.
cir::FuncType getFunctionType(const CIRGenFunctionInfo &info)
Get the CIR function type for.
mlir::Attribute emitAbstract(const Expr *e, QualType destType)
Emit the result of the given expression as an abstract constant, asserting that it succeeded.
AlignmentSource getAlignmentSource() const
void mergeForCast(const LValueBaseInfo &info)
const clang::Qualifiers & getQuals() const
mlir::Value getVectorIdx() const
Address getAddress() const
static LValue makeAddr(Address address, clang::QualType t, LValueBaseInfo baseInfo)
static LValue makeVectorElt(Address vecAddress, mlir::Value index, clang::QualType t, LValueBaseInfo baseInfo)
unsigned getVRQualifiers() const
clang::QualType getType() const
static LValue makeBitfield(Address addr, const CIRGenBitFieldInfo &info, clang::QualType type, LValueBaseInfo baseInfo)
Create a new object to represent a bit-field access.
mlir::Value getPointer() const
bool isVolatileQualified() const
Address getVectorAddress() const
clang::CharUnits getAlignment() const
LValueBaseInfo getBaseInfo() const
const CIRGenBitFieldInfo & getBitFieldInfo() const
Address getBitFieldAddress() const
This trivial value class is used to represent the result of an expression that is evaluated.
static RValue get(mlir::Value v)
static RValue getComplex(mlir::Value v)
mlir::Value getValue() const
Return the value of this scalar value.
Contains the address where the return value of a function can be stored, and whether the address is v...
Represents a call to a C++ constructor.
bool isElidable() const
Whether this construction is elidable.
Expr * getArg(unsigned Arg)
Return the specified argument.
bool requiresZeroInitialization() const
Whether this construction first requires zero-initialization before the initializer is called.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
CXXConstructionKind getConstructionKind() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
Represents a C++ constructor within a class.
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Represents a C++ destructor within a class.
Represents a call to a member function that may be written either with member call syntax (e....
Represents a static or instance method of a struct/union/class.
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Represents a C++ struct/union/class.
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
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
llvm::iterator_range< path_iterator > path()
Path through the class hierarchy taken by casts between base and derived classes (see implementation ...
bool changesVolatileQualification() const
Return.
static const char * getCastKindName(CastKind CK)
CharUnits - This is an opaque type for sizes expressed in character units.
CharUnits alignmentAtOffset(CharUnits offset) const
Given that this is a non-zero alignment value, what is the alignment at the given offset?
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.
Complex values, per C99 6.2.5p11.
CompoundLiteralExpr - [C99 6.5.2.5].
const Expr * getInitializer() const
ConditionalOperator - The ?
A reference to a declared variable, function, enum, etc.
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
static DeclRefExpr * Create(const ASTContext &Context, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *D, bool RefersToEnclosingVariableOrCapture, SourceLocation NameLoc, QualType T, ExprValueKind VK, NamedDecl *FoundD=nullptr, const TemplateArgumentListInfo *TemplateArgs=nullptr, NonOdrUseReason NOUR=NOUR_None)
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
SourceLocation getLocation() const
SourceLocation getLocation() const
DeclContext * getDeclContext()
This represents one expression.
const Expr * skipRValueSubobjectAdjustments(SmallVectorImpl< const Expr * > &CommaLHS, SmallVectorImpl< SubobjectAdjustment > &Adjustments) const
Walk outwards from an expression we want to bind a reference to and find the expression whose lifetim...
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Expr * IgnoreParens() LLVM_READONLY
Skip past any parentheses which might surround this expression until reaching a fixed point.
bool EvaluateAsRValue(EvalResult &Result, const ASTContext &Ctx, bool InConstantContext=false) const
EvaluateAsRValue - Return true if this is a constant which we can fold to an rvalue using any crazy t...
Decl * getReferencedDeclOfCallee()
bool isTemporaryObject(ASTContext &Ctx, const CXXRecordDecl *TempTy) const
Determine whether the result of this expression is a temporary object of the given class type.
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.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
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.
bool isZeroSize(const ASTContext &Ctx) const
Determine if this field is a subobject of zero size, that is, either a zero-length bit-field or a fie...
Represents a function declaration or definition.
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
FunctionDecl * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Represents a prototype with parameter type info, e.g.
GlobalDecl - represents a global declaration.
const Decl * getDecl() const
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
ValueDecl * getExtendingDecl()
Get the declaration which triggered the lifetime-extension of this temporary, if any.
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
NonOdrUseReason isNonOdrUse() const
Is this expression a non-odr-use reference, and if so, why?
SourceLocation getExprLoc() const LLVM_READONLY
A pointer to member type per C++ 8.3.3 - Pointers to members.
This represents a decl that may have a name.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
A C++ nested-name-specifier augmented with source location information.
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
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 ...
PointerType - C99 6.7.5.1 - Pointer Declarators.
A (possibly-)qualified type.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
QualType withCVRQualifiers(unsigned CVR) const
DestructionKind isDestructedType() const
Returns a nonzero value if objects of this type require non-trivial work to clean up after.
The collection of all-type qualifiers we support.
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
@ OCL_None
There is no lifetime qualification on this type.
void addCVRQualifiers(unsigned mask)
void addQualifiers(Qualifiers Q)
Add the qualifiers from the given set to this set.
Represents a struct/union/class.
Encodes a location in the source.
Stmt - This represents one statement.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
StringLiteral - This represents a string literal expression, e.g.
Exposes information about the current target.
virtual StringRef getABI() const
Get the ABI currently in use.
bool isBooleanType() const
const ArrayType * castAsArrayTypeUnsafe() const
A variant of castAs<> for array type which silently discards qualifiers from the outermost type.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isFunctionPointerType() const
CXXRecordDecl * castAsCXXRecordDecl() const
bool isArithmeticType() const
bool isConstantMatrixType() const
bool isPointerType() const
const T * castAs() const
Member-template castAs<specific type>.
bool isReferenceType() const
bool isVariableArrayType() const
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
bool isAnyComplexType() const
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isAtomicType() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isFunctionType() const
bool isVectorType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool hasBooleanRepresentation() const
Determine whether this type has a boolean representation – i.e., it is a boolean type,...
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
SourceLocation getExprLoc() const
Expr * getSubExpr() const
static bool isIncrementOp(Opcode Op)
static bool isPrefix(Opcode Op)
isPrefix - Return true if this is a prefix operation, like –x.
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
TLSKind getTLSKind() const
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
bool hasLocalStorage() const
Returns true if a variable with function scope is a non-static local variable.
@ TLS_Dynamic
TLS with a dynamic initializer.
Represents a C array with a specified size that is not an integer-constant-expression.
Represents a GCC generic vector type.
AlignmentSource
The source of the alignment of an l-value; an expression of confidence in the alignment actually matc...
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
static AlignmentSource getFieldAlignmentSource(AlignmentSource source)
Given that the base address has the given alignment source, what's our confidence in the alignment of...
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
const AstTypeMatcher< FunctionType > functionType
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
const internal::VariadicDynCastAllOfMatcher< Stmt, CastExpr > castExpr
Matches any cast nodes of Clang's AST.
The JSON file list parser is used to communicate input to InstallAPI.
CXXCtorType
C++ constructor types.
@ Ctor_Base
Base object ctor.
@ Ctor_Complete
Complete object ctor.
bool isa(CodeGen::Address addr)
@ SD_Thread
Thread storage duration.
@ SD_Static
Static storage duration.
@ SD_FullExpression
Full-expression storage duration (for temporaries).
@ SD_Automatic
Automatic storage duration (most local variables).
@ SD_Dynamic
Dynamic storage duration.
U cast(CodeGen::Address addr)
@ NOUR_Unevaluated
This name appears in an unevaluated operand.
@ NOUR_Constant
This name appears as a potential result of an lvalue-to-rvalue conversion that is a constant expressi...
static bool weakRefReference()
static bool objCLifetime()
static bool emitLifetimeMarkers()
static bool opLoadEmitScalarRangeCheck()
static bool addressSpace()
static bool opLoadStoreThreadLocal()
static bool opAllocaNonGC()
static bool opGlobalThreadLocal()
static bool opAllocaOpenMPThreadPrivate()
static bool preservedAccessIndexRegion()
static bool mergeAllConstants()
static bool opLoadStoreAtomic()
static bool opLoadStoreTbaa()
static bool cgFPOptionsRAII()
static bool opCallChain()
static bool opAllocaImpreciseLifetime()
static bool opAllocaStaticLocal()
static bool aggValueSlot()
static bool opAllocaTLS()
static bool emitCheckedInBoundsGEP()
static bool attributeNoBuiltin()
static bool setObjCGCLValueClass()
static bool cirgenABIInfo()
static bool opLoadStoreObjC()
static bool opCallArgEvaluationOrder()
static bool lambdaCaptures()
static bool insertBuiltinUnpredictable()
static bool opCallMustTail()
static bool shouldReverseUnaryCondOnBoolExpr()
static bool tryEmitAsConstant()
static bool addressIsKnownNonNull()
static bool astVarDeclInterface()
static bool cgCapturedStmtInfo()
static bool opAllocaEscapeByReference()
static bool opLoadStoreNontemporal()
static bool opCallFnInfoOpts()
static bool generateDebugInfo()
Record with information about how a bitfield should be accessed.
unsigned volatileStorageSize
The storage size in bits which should be used when accessing this bitfield.
unsigned volatileOffset
The offset within a contiguous run of bitfields that are represented as a single "field" within the c...
Represents a scope, including function bodies, compound statements, and the substatements of if/while...
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
bool HasSideEffects
Whether the evaluated expression has side effects.