clang: lib/CIR/CodeGen/CIRGenFunction.h Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
13#ifndef CLANG_LIB_CIR_CODEGEN_CIRGENFUNCTION_H
14#define CLANG_LIB_CIR_CODEGEN_CIRGENFUNCTION_H
15
22
24
37#include "llvm/ADT/ScopedHashTable.h"
38
39namespace {
40class ScalarExprEmitter;
41}
42
43namespace mlir {
47}
48
50
51struct CGCoroData;
52
54public:
56
57private:
58 friend class ::ScalarExprEmitter;
59
60
61
63
64
65
66 struct JumpDest {
67 JumpDest() = default;
69 unsigned index = 0)
70 : block(block) {}
71
72 bool isValid() const { return block != nullptr; }
73 mlir::Block *getBlock() const { return block; }
75 unsigned getDestIndex() const { return index; }
76
77
79 scopeDepth = depth;
80 }
81
82 private:
83 mlir::Block *block = nullptr;
86 };
87
88public:
89
90
92
93
94
95
99
101
102
104
105
106
107
112 };
114
116
117
118
120
121
123
125
126
127
128 llvm::DenseMap<const VarDecl *, mlir::Value> nrvoFlags;
129
130 llvm::DenseMap<const clang::ValueDecl *, clang::FieldDecl *>
133
134
135
140
141
142
145
146
147
149
150
152
154
155
156
157
158 mlir::Operation *curFn = nullptr;
159
160
162
163 using DeclMapTy = llvm::DenseMap<const clang::Decl *, Address>;
164
165
167
168
170
172
174
177
179
180 auto fn = mlir::castcir::FuncOp(curFn);
181 return &fn.getRegion().front();
182 }
183
184
186
187
188
189
190
191
192 using SymTableTy = llvm::ScopedHashTable<const clang::Decl *, mlir::Value>;
194
195
196
198
199
200
202
204
209
210
212 auto constOp = val.getDefiningOpcir::ConstantOp();
213 assert(constOp && "getIntValueFromConstOp call with non ConstantOp");
214 return constOp.getIntValue().getSExtValue();
215 }
216
217
218
220 auto constOp = val.getDefiningOpcir::ConstantOp();
221 assert(constOp &&
222 "getZeroExtendedIntValueFromConstOp call with non ConstantOp");
223 return constOp.getIntValue().getZExtValue();
224 }
225
226
228
232
236
238 bool suppressNewContext = false);
240
242
245
247 return cgm.getTargetCIRGenInfo();
248 }
249
250
251
252
253
254
255 llvm::DenseMap<const OpaqueValueExpr *, LValue> opaqueLValues;
256 llvm::DenseMap<const OpaqueValueExpr *, RValue> opaqueRValues;
257
258
259
260
261
262
263
264 llvm::DenseMap<const Expr *, mlir::Value> vlaSizeMap;
265
266public:
267
268
269
270
271
272
273 class OpaqueValueMappingData {
275 bool boundLValue;
276
278 : opaqueValue(ov), boundLValue(boundLValue) {}
279
280 public:
282
284
285
286
287
288
289 return expr->isGLValue() || expr->getType()->isFunctionType() ||
291 }
292
299
306
310 cgf.opaqueRValues.insert(std::make_pair(ov, rv));
311
312 OpaqueValueMappingData data(ov, false);
313
314
315
316
318 return data;
319 }
320
321 bool isValid() const { return opaqueValue != nullptr; }
322 void clear() { opaqueValue = nullptr; }
323
325 assert(opaqueValue && "no data to unbind!");
326
327 if (boundLValue) {
329 } else {
332 }
333 }
334 };
335
336
340
341 public:
345
346
347
348
349
350
353 : cgf(cgf) {
354 if (mlir::isa(op))
355
356 return;
357
359 mlir::cast(op);
362 }
363
364
365
367 : cgf(cgf) {
368 if (ov) {
369 assert(ov->getSourceExpr() && "wrong form of OpaqueValueMapping used "
370 "for OVE with no source expression");
372 }
373 }
374
379
384
386 data.unbind(cgf);
387 data.clear();
388 }
389
391 if (data.isValid())
392 data.unbind(cgf);
393 }
394 };
395
396private:
397
398
401 bool isParam = false);
402
403public:
405
407
408private:
409
411 class VarDeclContext {
414
415 public:
417 if (p.currVarDecl)
418 oldVal = p.currVarDecl;
419 p.currVarDecl = value;
420 }
421
422
423
424 void restore() { p.currVarDecl = oldVal; }
425 ~VarDeclContext() { restore(); }
426 };
427
428public:
429
430
434 std::optionalmlir::Location oldLoc;
435
436 public:
438 if (cgf.currSrcLoc)
439 oldLoc = cgf.currSrcLoc;
440 cgf.currSrcLoc = value;
441 }
442
443
444
445 void restore() { cgf.currSrcLoc = oldLoc; }
447 };
448
450 llvm::ScopedHashTableScope<const clang::Decl *, mlir::Value>;
451
452
457
458
461 mlir::Location getLoc(mlir::Location lhs, mlir::Location rhs);
462
464
465
466
467
468
469
471 return builder.getInsertionBlock() != nullptr;
472 }
473
474
475
484
486
487
489
490 [[maybe_unused]] const clang::Decl *calleeDecl;
491
492 public:
495
497 return llvm::isa_and_nonnullclang::FunctionDecl(calleeDecl);
498 }
499
501 if (const auto *fd = llvm::dyn_castclang::FunctionDecl(calleeDecl))
502 return fd->getNumParams();
503 return llvm::castclang::ObjCMethodDecl(calleeDecl)->param_size();
504 }
505
507 if (const auto *fd = llvm::dyn_castclang::FunctionDecl(calleeDecl))
508 return fd->getParamDecl(I);
509 return *(llvm::castclang::ObjCMethodDecl(calleeDecl)->param_begin() +
510 I);
511 }
512 };
513
520
521
522
524
525
526
527
528
531
533
537
539
540
541
543
544
545
546
548 bool allowLabels = false);
550 llvm::APSInt &resultInt,
551 bool allowLabels = false);
552
553
554
555
557
559
560 class ConstantEmission {
561
562 llvm::PointerIntPair<mlir::Attribute, 1, bool> valueAndIsReference;
565
566 public:
571 static ConstantEmission forValue(mlir::TypedAttr c) {
573 }
574
575 explicit operator bool() const {
576 return valueAndIsReference.getOpaqueValue() != nullptr;
577 }
578
579 bool isReference() const { return valueAndIsReference.getInt(); }
583 "ConstantEmission::getReferenceLValue");
584 return {};
585 }
586
589 return mlir::castmlir::TypedAttr(valueAndIsReference.getPointer());
590 }
591 };
592
595
598
599
600
601
603
604
605
607
608
609
611
612
613
615
617
620
623
625
627
629
630
631
632
634
635
636
637
639
640
641
642
650 };
651
652
653
654
655
656
658 return JumpDest(target, ehStack.getInnermostNormalCleanup(),
660 }
661
662
663
664
666
669
670
671
673
675 cir::GlobalOp gv,
676 cir::GetGlobalOp gvAddr);
677
678
679
680
682
683
684
685
687 switch (kind) {
689 return false;
696 cgm.getCodeGenOpts().ObjCAutoRefCountExceptions;
697 }
698 llvm_unreachable("bad destruction kind");
699 }
700
704
706
707
709 assert(.count(vd) && "Decl already exists in LocalDeclMap!");
711
712
714 return;
716 }
717
718
719
723
724
725
726
727
731 bool shouldDelete = false;
733
734 public:
736 : cgf(cgf), vd(vd) {
737 auto mapItr = cgf.localDeclMap.find(vd);
738
739 if (mapItr != cgf.localDeclMap.end())
740 oldAddr = mapItr->second;
741 else
742 shouldDelete = true;
743 }
744
746 if (shouldDelete)
747 cgf.localDeclMap.erase(vd);
748 else
749 cgf.localDeclMap.insert_or_assign(vd, oldAddr);
750 }
751 };
752
754
757
758 static bool
760
767
770
776 bool baseIsNonVirtualPrimaryBase,
779
782
783
784
785
787
788
789
793
794
795
796
798 public:
801 cgf.cxxDefaultInitExprThis = thisAddr;
802 }
804 cgf.cxxDefaultInitExprThis = oldCXXDefaultInitExprThis;
805 }
806
807 private:
809 Address oldCXXDefaultInitExprThis;
810 };
811
812
813
815 public:
820 cgf.cxxThisValue = cgf.cxxDefaultInitExprThis.getPointer();
821 cgf.cxxThisAlignment = cgf.cxxDefaultInitExprThis.getAlignment();
822 }
827
828 public:
833 };
834
839
842
843
844
845
846
849 bool forPointeeType = false,
851 if (alignment.isZero())
852 alignment = cgm.getNaturalTypeAlignment(t, baseInfo);
854 }
855
858 llvm::iterator_rangeCastExpr::path\_const\_iterator path,
860
863 llvm::iterator_rangeCastExpr::path\_const\_iterator path,
864 bool nullCheckValue);
865
866
867
868
869
871 bool delegating);
872
877
881
885
887
888
892 "Invalid argument to getAddrOfLocalVar(), no decl!");
893 return it->second;
894 }
895
897 mlir::Type fieldType, unsigned index);
898
899
900
902
903
904
906
907
908
909
911 assert(cxxThisValue && "no 'this' value for this function");
913 }
915
916
917
918
923
924
929 bool baseIsVirtual);
930
931
938
939
940
943 bool isVirtual);
944
945
946
947
948
950
952 cir::FuncType funcType);
953
956
957
958
961
962
963
964
966 cir::FuncOp fn, cir::FuncType funcType,
969
970
973 return rd->hasVolatileMember();
974 return false;
975 }
976
979 cir::TryOp tryOp);
980
981
982
984
987
988
989
992
993
994
995
996 template <class T, class... As>
998
999
1001 return ehStack.pushCleanup<T>(kind, a...);
1002
1003 cgm.errorNYI("pushFullExprCleanup in conditional branch");
1004 }
1005
1006
1007
1008 class RunCleanupsScope {
1010
1011 protected:
1014
1015 private:
1016 RunCleanupsScope(const RunCleanupsScope &) = delete;
1017 void operator=(const RunCleanupsScope &) = delete;
1018
1019 protected:
1021
1022 public:
1023
1026 cleanupStackDepth = cgf.ehStack.stable_begin();
1028 cgf.didCallStackSave = false;
1029 oldCleanupStackDepth = cgf.currentCleanupStackDepth;
1030 cgf.currentCleanupStackDepth = cleanupStackDepth;
1031 }
1032
1033
1038
1039
1040
1043 {
1044 mlir::OpBuilder::InsertionGuard guard(cgf.getBuilder());
1046 cgf.popCleanupBlocks(cleanupStackDepth);
1048 cgf.currentCleanupStackDepth = oldCleanupStackDepth;
1049 }
1050 }
1051 };
1052
1053
1055
1056public:
1057
1058
1059
1061 private:
1062
1063
1064 mlir::Block *cleanupBlock = nullptr;
1065
1066
1067
1068
1069 mlir::Block *entryBlock;
1070
1072
1073
1074 cir::TryOp tryOp = nullptr;
1075
1076
1077
1078 enum Kind {
1079 Regular,
1080 Ternary,
1081 Switch,
1082 Try,
1083 GlobalInit
1084 };
1085 Kind scopeKind = Kind::Regular;
1086
1087
1088 mlir::Value retVal = nullptr;
1089
1090 mlir::Location beginLoc;
1091 mlir::Location endLoc;
1092
1093 public:
1095
1097 : RunCleanupsScope(cgf), entryBlock(eb), parentScope(cgf.curLexScope),
1098 beginLoc(loc), endLoc(loc) {
1099
1100 assert(entryBlock && "LexicalScope requires an entry block");
1101 cgf.curLexScope = this;
1102 if (parentScope)
1104
1105 if (const auto fusedLoc = mlir::dyn_castmlir::FusedLoc(loc)) {
1106 assert(fusedLoc.getLocations().size() == 2 && "too many locations");
1107 beginLoc = fusedLoc.getLocations()[0];
1108 endLoc = fusedLoc.getLocations()[1];
1109 }
1110 }
1111
1113
1116
1122
1123
1124
1125
1126 bool isGlobalInit() { return scopeKind == Kind::GlobalInit; }
1127 bool isRegular() { return scopeKind == Kind::Regular; }
1128 bool isSwitch() { return scopeKind == Kind::Switch; }
1129 bool isTernary() { return scopeKind == Kind::Ternary; }
1130 bool isTry() { return scopeKind == Kind::Try; }
1136 scopeKind = Kind::Try;
1137 tryOp = op;
1138 }
1139
1140
1142 if (cleanupBlock)
1143 return cleanupBlock;
1145 return cleanupBlock;
1146 }
1147
1149 assert(isTry());
1150 return tryOp;
1151 }
1152
1154 return cleanupBlock;
1155 }
1156
1158
1159 mlir::OpBuilder::InsertionGuard guard(builder);
1160 mlir::Region *r = builder.getBlock() ? builder.getBlock()->getParent()
1161 : &cgf.curFn->getRegion(0);
1162 cleanupBlock = builder.createBlock(r);
1163 return cleanupBlock;
1164 }
1165
1166
1167
1168
1169
1170 private:
1171
1172
1173
1174
1175
1177 llvm::DenseMap<mlir::Block *, mlir::Location> retLocs;
1178 llvm::DenseMap<cir::CaseOp, unsigned> retBlockInCaseIndex;
1179 std::optional normalRetBlockIndex;
1180
1181
1182
1183
1184 mlir::Block *createRetBlock(CIRGenFunction &cgf, mlir::Location loc) {
1185 assert((isa_and_nonnullcir::CaseOp(
1186 cgf.builder.getBlock()->getParentOp()) ||
1187 retBlocks.size() == 0) &&
1188 "only switches can hold more than one ret block");
1189
1190
1191 mlir::OpBuilder::InsertionGuard guard(cgf.builder);
1192 auto *b = cgf.builder.createBlock(cgf.builder.getBlock()->getParent());
1193 retBlocks.push_back(b);
1195 return b;
1196 }
1197
1198 cir::ReturnOp emitReturn(mlir::Location loc);
1199 void emitImplicitReturn();
1200
1201 public:
1203 mlir::Location getRetLoc(mlir::Block *b) { return retLocs.at(b); }
1205 retLocs.insert_or_assign(b, loc);
1206 }
1207
1209
1210 if (auto caseOp = mlir::dyn_cast_if_presentcir::CaseOp(
1211 cgf.builder.getBlock()->getParentOp())) {
1212 auto iter = retBlockInCaseIndex.find(caseOp);
1213 if (iter != retBlockInCaseIndex.end()) {
1214
1215 mlir::Block *ret = retBlocks[iter->second];
1217 return ret;
1218 }
1219
1220 mlir::Block *ret = createRetBlock(cgf, loc);
1221 retBlockInCaseIndex[caseOp] = retBlocks.size() - 1;
1222 return ret;
1223 }
1224
1225 if (normalRetBlockIndex) {
1226 mlir::Block *ret = retBlocks[*normalRetBlockIndex];
1228 return ret;
1229 }
1230
1231 mlir::Block *ret = createRetBlock(cgf, loc);
1232 normalRetBlockIndex = retBlocks.size() - 1;
1233 return ret;
1234 }
1235
1237 };
1238
1240
1242
1244
1247
1250
1252
1253
1254
1255
1256public:
1257 std::optionalmlir::Value
1260 llvm::Triple::ArchType arch);
1265
1269 int64_t alignment,
1270 mlir::Value offsetValue = nullptr);
1271
1274 int64_t alignment,
1275 mlir::Value offsetValue = nullptr);
1276
1277private:
1280
1282
1283public:
1285 llvm::StringRef fieldName,
1286 unsigned fieldIndex);
1287
1288 mlir::Value emitAlloca(llvm::StringRef name, mlir::Type ty,
1290 bool insertIntoFnEntryBlock,
1291 mlir::Value arraySize = nullptr);
1292 mlir::Value emitAlloca(llvm::StringRef name, mlir::Type ty,
1294 mlir::OpBuilder::InsertPoint ip,
1295 mlir::Value arraySize = nullptr);
1296
1298
1300
1302
1303
1304
1305
1306
1307
1308
1309
1312 bool isVolatile = false);
1313
1314
1315
1316
1317
1320 bool ignoreResult = false);
1321
1322
1323
1325 bool isInitializer);
1326
1327
1328
1330
1332
1333 void emitArrayDestroy(mlir::Value begin, mlir::Value numElements,
1336
1340
1342
1345
1347
1352 bool isVolatile, bool isInit);
1353
1355 mlir::OpBuilder::InsertPoint ip = {});
1356
1357
1358
1359
1361
1363
1364
1365
1366
1367
1371
1373
1376
1378
1380
1382
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1399 cir::IntType resType, mlir::Value emittedE,
1400 bool isDynamic);
1401
1403 unsigned type,
1404 cir::IntType resType,
1405 mlir::Value emittedE,
1406 bool isDynamic);
1407
1409
1411
1414 const CallArgList &args, cir::CIRCallOpInterface *callOp,
1415 mlir::Location loc);
1419 cir::CIRCallOpInterface *callOrTryCall = nullptr) {
1420 assert(currSrcLoc && "source location must have been set");
1423 }
1424
1430 CallArgList &args, PrototypeWrapper prototype,
1431 llvm::iterator_rangeclang::CallExpr::const\_arg\_iterator argRange,
1432 AbstractCallee callee = AbstractCallee(), unsigned paramsToSkip = 0);
1437
1438 template
1440 mlir::ArrayAttr value,
1441 cir::CaseOpKind kind,
1442 bool buildingTopLevelCase);
1443
1445 mlir::Type condType,
1446 bool buildingTopLevelCase);
1447
1449
1450
1451
1453
1454
1455
1458
1461
1463
1469 mlir::Value coroframeAddr);
1471
1473
1475
1477
1480
1484 bool newPointerIsChecked,
1485 bool zeroInitialize = false);
1487 mlir::Value numElements, Address arrayBase,
1489 bool newPointerIsChecked,
1490 bool zeroInitialize);
1495
1498 bool delegating, Address thisAddr,
1500
1502
1504 bool forVirtualBase, bool delegating,
1506
1508 mlir::Value thisVal, QualType thisTy,
1509 mlir::Value implicitParam,
1511
1514
1517
1519 const Expr *e, Address base, mlir::Value memberPtr,
1521
1525 mlir::Value implicitParam, clang::QualType implicitParamTy,
1527
1533
1535
1537 mlir::Type elementTy, Address beginPtr,
1538 mlir::Value numElements,
1539 mlir::Value allocSizeWithoutCookie);
1540
1544
1546
1550
1553
1555
1557
1559
1561 bool isFnTryBlock = false);
1562
1564
1567
1568
1569
1570
1571
1574
1577
1579
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1593 LValue lvalue, bool capturedByInit = false);
1594
1596
1598
1600
1602
1605
1607
1609
1611
1613
1615
1616 mlir::Value emitRuntimeCall(mlir::Location loc, cir::FuncOp callee,
1618
1619
1621 bool ignoreResultAssign = false);
1622
1624 cir::UnaryOpKind kind, bool isPre);
1625
1626
1628
1629
1630
1633
1635 bool useCurrentScope);
1636
1638
1640 CallArgList &callArgs);
1641
1644 bool ignoreResult = false);
1645
1646
1648
1650
1652 cir::UnaryOpKind op, bool isPre);
1653
1657 mlir::Value &result);
1658
1659 mlir::LogicalResult
1662
1663 mlir::LogicalResult
1665 Address *lastValue = nullptr,
1667
1668 void emitDecl(const clang::Decl &d, bool evaluateConditionDecl = false);
1671
1673 mlir::Type condType,
1674 bool buildingTopLevelCase);
1675
1678 const FunctionArgList &args,
1680
1681
1682
1683
1686
1687
1688
1689
1690
1691
1692
1698 mlir::Location thenLoc,
1700 std::optionalmlir::Location elseLoc = {});
1701
1703
1705
1708
1711
1713
1715
1716
1717
1719
1721
1722
1724
1726
1727
1728
1729
1731
1733 LValueBaseInfo *pointeeBaseInfo);
1735 QualType refTy, AlignmentSource source);
1736
1737
1738
1739
1740
1741 mlir::Value emitLoadOfScalar(LValue lvalue, SourceLocation loc);
1742 mlir::Value emitLoadOfScalar(Address addr, bool isVolatile, QualType ty,
1743 SourceLocation loc, LValueBaseInfo baseInfo);
1744
1745
1746
1747
1751
1754 mlir::Value thisValue);
1755
1756
1757
1758
1761 llvm::StringRef fieldName);
1762
1764
1766
1768
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1782 LValueBaseInfo *baseInfo = nullptr);
1783
1784
1786
1788
1789 RValue emitRotate(const CallExpr *e, bool isRotateLeft);
1790
1791 mlir::Value emitScalarConstant(const ConstantEmission &constant, Expr *e);
1792
1793
1794
1798
1800 LValue lvalue, bool capturedByInit = false);
1801
1803 const Expr *argExpr);
1804
1805 void emitStaticVarDecl(const VarDecl &d, cir::GlobalLinkageKind linkage);
1806
1807 void emitStoreOfComplex(mlir::Location loc, mlir::Value v, LValue dest,
1808 bool isInit);
1809
1810 void emitStoreOfScalar(mlir::Value value, Address addr, bool isVolatile,
1812 bool isInit = false, bool isNontemporal = false);
1813 void emitStoreOfScalar(mlir::Value value, LValue lvalue, bool isInit);
1814
1815
1816
1817
1819
1821
1823 llvm::StringRef name = ".str");
1824
1827 bool buildingTopLevelCase);
1829
1830 std::optionalmlir::Value
1833
1834
1835
1836
1837
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848 void emitTrap(mlir::Location loc, bool createNewBlock);
1849
1851
1852 mlir::Value emitUnPromotedValue(mlir::Value result, QualType unPromotionType);
1853
1854
1855
1856
1857
1858
1859
1860
1861
1863
1864
1865
1867
1869
1871
1873 const CallExpr *expr);
1874
1875
1876
1879
1880
1883 mlir::OpBuilder::InsertPoint insertPt;
1884
1885 public:
1887 : cgf(cgf), insertPt(cgf.builder.saveInsertionPoint()) {}
1889 : cgf(cgf), insertPt(ip) {}
1890
1892 assert(cgf.outermostConditional != this);
1893 if (!cgf.outermostConditional)
1894 cgf.outermostConditional = this;
1895 }
1896
1898 assert(cgf.outermostConditional != nullptr);
1899 if (cgf.outermostConditional == this)
1900 cgf.outermostConditional = nullptr;
1901 }
1902
1903
1904
1905
1906 mlir::OpBuilder::InsertPoint getInsertPoint() const { return insertPt; }
1907 };
1908
1913
1914
1915
1917
1920 {
1921 mlir::OpBuilder::InsertionGuard guard(builder);
1923 builder.createStore(
1924 value.getLoc(), value, addr, false,
1925 mlir::IntegerAttr::get(
1926 mlir::IntegerType::get(value.getContext(), 64),
1928 }
1929 }
1930
1931
1932
1934
1935
1936
1939
1940
1941
1942
1944
1945 public:
1948 cgf.outermostConditional = nullptr;
1949 }
1950
1952 cgf.outermostConditional = savedOutermostConditional;
1953 }
1954 };
1955
1956 template
1958 const FuncTy &branchGenFunc);
1959
1963
1964
1965
1967
1968
1969
1970
1971
1972
1973
1974 void emitVAStart(mlir::Value vaList, mlir::Value count);
1975
1976
1977
1978
1979
1980 void emitVAEnd(mlir::Value vaList);
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1992
1993
1994
1995
1996public:
1997 cir::AllocaOp createTempAlloca(mlir::Type ty, mlir::Location loc,
1998 const Twine &name = "tmp",
1999 mlir::Value arraySize = nullptr,
2000 bool insertIntoFnEntryBlock = false);
2001 cir::AllocaOp createTempAlloca(mlir::Type ty, mlir::Location loc,
2002 const Twine &name = "tmp",
2003 mlir::OpBuilder::InsertPoint ip = {},
2004 mlir::Value arraySize = nullptr);
2006 const Twine &name = "tmp",
2007 mlir::Value arraySize = nullptr,
2008 Address *alloca = nullptr,
2009 mlir::OpBuilder::InsertPoint ip = {});
2011 mlir::Location loc,
2012 const Twine &name = "tmp",
2013 mlir::Value arraySize = nullptr,
2014 mlir::OpBuilder::InsertPoint ip = {});
2015
2016
2017
2018
2019 Address createMemTemp(QualType t, mlir::Location loc,
2020 const Twine &name = "tmp", Address *alloca = nullptr,
2021 mlir::OpBuilder::InsertPoint ip = {});
2022 Address createMemTemp(QualType t, CharUnits align, mlir::Location loc,
2023 const Twine &name = "tmp", Address *alloca = nullptr,
2024 mlir::OpBuilder::InsertPoint ip = {});
2025
2026
2027
2028
2029public:
2049 mlir::LogicalResult
2051 mlir::LogicalResult
2053 mlir::LogicalResult
2055 mlir::LogicalResult
2066 mlir::LogicalResult
2069 mlir::LogicalResult
2071 mlir::LogicalResult
2073 mlir::LogicalResult
2075 mlir::LogicalResult
2077 mlir::LogicalResult
2080 mlir::LogicalResult
2082 mlir::LogicalResult
2084 mlir::LogicalResult
2086 mlir::LogicalResult
2088 mlir::LogicalResult
2090 mlir::LogicalResult
2092 mlir::LogicalResult
2095 const OMPParallelMaskedTaskLoopDirective &s);
2097 const OMPParallelMaskedTaskLoopSimdDirective &s);
2099 const OMPParallelMasterTaskLoopDirective &s);
2101 const OMPParallelMasterTaskLoopSimdDirective &s);
2102 mlir::LogicalResult
2105 const OMPDistributeParallelForDirective &s);
2107 const OMPDistributeParallelForSimdDirective &s);
2108 mlir::LogicalResult
2111 const OMPTargetParallelGenericLoopDirective &s);
2113 const OMPTargetParallelForSimdDirective &s);
2114 mlir::LogicalResult
2117 const OMPTargetTeamsGenericLoopDirective &s);
2118 mlir::LogicalResult
2120 mlir::LogicalResult
2122 mlir::LogicalResult
2125 const OMPTeamsDistributeParallelForSimdDirective &s);
2127 const OMPTeamsDistributeParallelForDirective &s);
2128 mlir::LogicalResult
2130 mlir::LogicalResult
2133 const OMPTargetTeamsDistributeDirective &s);
2135 const OMPTargetTeamsDistributeParallelForDirective &s);
2137 const OMPTargetTeamsDistributeParallelForSimdDirective &s);
2139 const OMPTargetTeamsDistributeSimdDirective &s);
2142 mlir::LogicalResult
2145 mlir::LogicalResult
2150
2158
2159private:
2160 template
2161 void emitOpenMPClauses(Op &op, ArrayRef<const OMPClause *> clauses);
2162
2163
2164
2165
2166private:
2167 template
2169 llvm::ArrayRef<const OpenACCClause *> clauses);
2170
2171
2172 template <typename Op, typename TermOp>
2173 mlir::LogicalResult
2174 emitOpenACCOpAssociatedStmt(mlir::Location start, mlir::Location end,
2176 llvm::ArrayRef<const OpenACCClause *> clauses,
2177 const Stmt *associatedStmt);
2178
2179 template <typename Op, typename TermOp>
2180 mlir::LogicalResult emitOpenACCOpCombinedConstruct(
2182 llvm::ArrayRef<const OpenACCClause *> clauses, const Stmt *loopStmt);
2183
2184 template
2186 ArrayRef<const OpenACCClause *> clauses);
2187
2188
2189
2190
2191
2192
2193 template <typename ComputeOp, typename LoopOp>
2194 void emitOpenACCClauses(ComputeOp &op, LoopOp &loopOp,
2196 ArrayRef<const OpenACCClause *> clauses);
2197
2198
2199
2200
2201 void updateLoopOpParallelism(mlir::acc::LoopOp &op, bool isOrphan,
2203
2204
2205
2206 mlir::acc::LoopOp *activeLoopOp = nullptr;
2207
2208 struct ActiveOpenACCLoopRAII {
2210 mlir::acc::LoopOp *oldLoopOp;
2211
2212 ActiveOpenACCLoopRAII(CIRGenFunction &cgf, mlir::acc::LoopOp *newOp)
2213 : cgf(cgf), oldLoopOp(cgf.activeLoopOp) {
2214 cgf.activeLoopOp = newOp;
2215 }
2216 ~ActiveOpenACCLoopRAII() { cgf.activeLoopOp = oldLoopOp; }
2217 };
2218
2219
2220
2221 mlir::OpBuilder::InsertPoint lastRecipeLocation;
2222
2223public:
2224
2225
2230
2231
2232
2236
2237
2239 };
2240
2241
2242
2244
2245
2247
2248
2250 int64_t value);
2251
2252 mlir::LogicalResult
2255 mlir::LogicalResult
2258 mlir::LogicalResult
2260 mlir::LogicalResult
2262 mlir::LogicalResult
2266 mlir::LogicalResult
2269 mlir::LogicalResult
2271 mlir::LogicalResult
2274
2277
2278
2280 const Twine &name = "tmp",
2281 Address *alloca = nullptr) {
2287 }
2288
2289private:
2291};
2292
2293}
2294
2295#endif
Defines the clang::ASTContext interface.
llvm::function_ref< void(mlir::OpBuilder &, mlir::Location)> BuilderCallbackRef
Defines the clang::Expr interface and subclasses for C++ expressions.
Defines an enumeration for C++ overloaded operators.
C Language Family Type Representation.
__device__ __2f16 float __ockl_bool s
__device__ __2f16 float c
Represents a member of a struct/union/class.
This class represents a 'loop' construct. The 'loop' construct applies to a 'for' loop (or range-for ...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
AbstractConditionalOperator - An abstract base class for ConditionalOperator and BinaryConditionalOpe...
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Represents an array type, per C99 6.7.5.2 - Array Declarators.
AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
Expr * getCommon() const
getCommon - Return the common expression, written to the left of the condition.
A builtin binary operation expression such as "x + y" or "x <= y".
BreakStmt - This represents a break.
mlir::Value getPointer() const
clang::CharUnits getAlignment() const
mlir::Value getBasePointer() const
static AggValueSlot forAddr(Address addr, clang::Qualifiers quals, IsDestructed_t isDestructed, IsAliased_t isAliased, Overlap_t mayOverlap, IsZeroed_t isZeroed=IsNotZeroed)
static AggValueSlot ignored()
Returns an aggregate value slot indicating that the aggregate value is being ignored.
AbstractCallee()
Definition CIRGenFunction.h:493
bool hasFunctionDecl() const
Definition CIRGenFunction.h:496
unsigned getNumParams() const
Definition CIRGenFunction.h:500
AbstractCallee(const clang::FunctionDecl *fd)
Definition CIRGenFunction.h:494
const clang::ParmVarDecl * getParamDecl(unsigned I) const
Definition CIRGenFunction.h:506
SourceLocExprScopeGuard sourceLocScope
Definition CIRGenFunction.h:832
CXXDefaultInitExprScope(CIRGenFunction &cgf, const CXXDefaultInitExpr *e)
Definition CIRGenFunction.h:816
clang::CharUnits oldCXXThisAlignment
Definition CIRGenFunction.h:831
mlir::Value oldCXXThisValue
Definition CIRGenFunction.h:830
CIRGenFunction & cgf
Definition CIRGenFunction.h:829
~CXXDefaultInitExprScope()
Definition CIRGenFunction.h:823
An object to manage conditionally-evaluated expressions.
Definition CIRGenFunction.h:1881
ConditionalEvaluation(CIRGenFunction &cgf, mlir::OpBuilder::InsertPoint ip)
Definition CIRGenFunction.h:1888
void beginEvaluation()
Definition CIRGenFunction.h:1891
void endEvaluation()
Definition CIRGenFunction.h:1897
mlir::OpBuilder::InsertPoint getInsertPoint() const
Returns the insertion point which will be executed prior to each evaluation of the conditional code.
Definition CIRGenFunction.h:1906
ConditionalEvaluation(CIRGenFunction &cgf)
Definition CIRGenFunction.h:1886
static ConstantEmission forReference(mlir::TypedAttr c)
Definition CIRGenFunction.h:568
ConstantEmission()
Definition CIRGenFunction.h:567
static ConstantEmission forValue(mlir::TypedAttr c)
Definition CIRGenFunction.h:571
LValue getReferenceLValue(CIRGenFunction &cgf, Expr *refExpr) const
Definition CIRGenFunction.h:580
mlir::TypedAttr getValue() const
Definition CIRGenFunction.h:587
bool isReference() const
Definition CIRGenFunction.h:579
DeclMapRevertingRAII(CIRGenFunction &cgf, const VarDecl *vd)
Definition CIRGenFunction.h:735
~DeclMapRevertingRAII()
Definition CIRGenFunction.h:745
~FieldConstructionScope()
Definition CIRGenFunction.h:803
FieldConstructionScope(CIRGenFunction &cgf, Address thisAddr)
Definition CIRGenFunction.h:799
A non-RAII class containing all the information about a bound opaque value.
Definition CIRGenFunction.h:273
static OpaqueValueMappingData bind(CIRGenFunction &cgf, const OpaqueValueExpr *ov, const LValue &lv)
Definition CIRGenFunction.h:301
static OpaqueValueMappingData bind(CIRGenFunction &cgf, const OpaqueValueExpr *ov, const RValue &rv)
Definition CIRGenFunction.h:308
void clear()
Definition CIRGenFunction.h:322
static bool shouldBindAsLValue(const Expr *expr)
Definition CIRGenFunction.h:283
bool isValid() const
Definition CIRGenFunction.h:321
OpaqueValueMappingData()
Definition CIRGenFunction.h:281
static OpaqueValueMappingData bind(CIRGenFunction &cgf, const OpaqueValueExpr *ov, const Expr *e)
Definition CIRGenFunction.h:294
void unbind(CIRGenFunction &cgf)
Definition CIRGenFunction.h:324
~OpaqueValueMapping()
Definition CIRGenFunction.h:390
OpaqueValueMapping(CIRGenFunction &cgf, const OpaqueValueExpr *opaqueValue, RValue rvalue)
Definition CIRGenFunction.h:380
OpaqueValueMapping(CIRGenFunction &cgf, const OpaqueValueExpr *opaqueValue, LValue lvalue)
Definition CIRGenFunction.h:375
OpaqueValueMapping(CIRGenFunction &cgf, const AbstractConditionalOperator *op)
Build the opaque value mapping for the given conditional operator if it's the GNU ?
Definition CIRGenFunction.h:351
OpaqueValueMapping(CIRGenFunction &cgf, const OpaqueValueExpr *ov)
Build the opaque value mapping for an OpaqueValueExpr whose source expression is set to the expressio...
Definition CIRGenFunction.h:366
void pop()
Definition CIRGenFunction.h:385
static bool shouldBindAsLValue(const Expr *expr)
Definition CIRGenFunction.h:342
RunCleanupsScope(CIRGenFunction &cgf)
Enter a new cleanup scope.
Definition CIRGenFunction.h:1024
bool performCleanup
Definition CIRGenFunction.h:1012
CIRGenFunction & cgf
Definition CIRGenFunction.h:1020
void forceCleanup()
Force the emission of cleanups now, instead of waiting until this object is destroyed.
Definition CIRGenFunction.h:1041
bool oldDidCallStackSave
Definition CIRGenFunction.h:1013
~RunCleanupsScope()
Exit this cleanup scope, emitting any accumulated cleanups.
Definition CIRGenFunction.h:1034
void restore()
Can be used to restore the state early, before the dtor is run.
Definition CIRGenFunction.h:445
~SourceLocRAIIObject()
Definition CIRGenFunction.h:446
SourceLocRAIIObject(CIRGenFunction &cgf, mlir::Location value)
Definition CIRGenFunction.h:437
StmtExprEvaluation(CIRGenFunction &cgf)
Definition CIRGenFunction.h:1946
~StmtExprEvaluation()
Definition CIRGenFunction.h:1951
Definition CIRGenFunction.h:53
static bool isConstructorDelegationValid(const clang::CXXConstructorDecl *ctor)
Checks whether the given constructor is a valid subject for the complete-to-base constructor delegati...
static bool hasScalarEvaluationKind(clang::QualType type)
Definition CIRGenFunction.h:229
void emitFunctionProlog(const FunctionArgList &args, mlir::Block *entryBB, const FunctionDecl *fd, SourceLocation bodyBeginLoc)
Emit the function prologue: declare function arguments in the symbol table.
void emitOpenACCRoutine(const OpenACCRoutineDecl &d)
void emitLambdaDelegatingInvokeBody(const CXXMethodDecl *md)
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,...
cir::CallOp emitCoroIDBuiltinCall(mlir::Location loc, mlir::Value nullPtr)
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)
cir::GlobalOp addInitializerToStaticVarDecl(const VarDecl &d, cir::GlobalOp gv, cir::GetGlobalOp gvAddr)
Add the initializer for 'd' to the global variable that has already been created for it.
mlir::LogicalResult emitOMPTargetParallelForDirective(const OMPTargetParallelForDirective &s)
mlir::LogicalResult emitOMPParallelMasterTaskLoopSimdDirective(const OMPParallelMasterTaskLoopSimdDirective &s)
mlir::LogicalResult emitOMPSimdDirective(const OMPSimdDirective &s)
mlir::Value emitCheckedArgForAssume(const Expr *e)
Emits an argument for a call to a __builtin_assume.
LValue emitOpaqueValueLValue(const OpaqueValueExpr *e)
mlir::LogicalResult emitDoStmt(const clang::DoStmt &s)
mlir::LogicalResult emitOMPCriticalDirective(const OMPCriticalDirective &s)
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...
Definition CIRGenFunction.h:91
clang::CurrentSourceLocExprScope::SourceLocExprScopeGuard SourceLocExprScopeGuard
Definition CIRGenFunction.h:791
RValue convertTempToRValue(Address addr, clang::QualType type, clang::SourceLocation loc)
Given the address of a temporary variable, produce an r-value of its type.
mlir::LogicalResult emitOpenACCDataConstruct(const OpenACCDataConstruct &s)
AutoVarEmission emitAutoVarAlloca(const clang::VarDecl &d, mlir::OpBuilder::InsertPoint ip={})
mlir::Value emitPromotedValue(mlir::Value result, QualType promotionType)
void emitAutoVarTypeCleanup(const AutoVarEmission &emission, clang::QualType::DestructionKind dtorKind)
Enter a destroy cleanup for the given local variable.
ImplicitParamDecl * cxxabiThisDecl
CXXThisDecl - When generating code for a C++ member function, this will hold the implicit 'this' decl...
Definition CIRGenFunction.h:136
EHScopeStack::stable_iterator prologueCleanupDepth
The cleanup depth enclosing all the cleanups associated with the parameters.
Definition CIRGenFunction.h:983
mlir::LogicalResult emitOpenACCCombinedConstruct(const OpenACCCombinedConstruct &s)
Address emitCXXMemberDataPointerAddress(const Expr *e, Address base, mlir::Value memberPtr, const MemberPointerType *memberPtrType, LValueBaseInfo *baseInfo)
mlir::LogicalResult emitOMPParallelMasterDirective(const OMPParallelMasterDirective &s)
mlir::LogicalResult emitOpenACCWaitConstruct(const OpenACCWaitConstruct &s)
cir::FuncOp generateCode(clang::GlobalDecl gd, cir::FuncOp fn, cir::FuncType funcType)
mlir::LogicalResult emitOMPCancellationPointDirective(const OMPCancellationPointDirective &s)
mlir::Value cxxThisValue
Definition CIRGenFunction.h:138
mlir::LogicalResult emitOMPParallelMaskedTaskLoopDirective(const OMPParallelMaskedTaskLoopDirective &s)
CIRGenTypes & getTypes() const
Definition CIRGenFunction.h:241
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...
llvm::ScopedHashTable< const clang::Decl *, mlir::Value > SymTableTy
The symbol table maps a variable name to a value in the current scope.
Definition CIRGenFunction.h:192
mlir::LogicalResult emitOMPReverseDirective(const OMPReverseDirective &s)
void emitVariablyModifiedType(QualType ty)
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
Definition CIRGenFunction.h:463
mlir::Value cxxStructorImplicitParamValue
Definition CIRGenFunction.h:144
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...
void emitForwardingCallToLambda(const CXXMethodDecl *lambdaCallOperator, CallArgList &callArgs)
mlir::Block * getCurFunctionEntryBlock()
Definition CIRGenFunction.h:178
void enterCXXTryStmt(const CXXTryStmt &s, cir::TryOp tryOp, bool isFnTryBlock=false)
RValue emitCXXMemberCallExpr(const clang::CXXMemberCallExpr *e, ReturnValueSlot returnValue)
mlir::LogicalResult emitOpenACCUpdateConstruct(const OpenACCUpdateConstruct &s)
bool isInConditionalBranch() const
Definition CIRGenFunction.h:1916
LValue emitLValueForBitField(LValue base, const FieldDecl *field)
mlir::LogicalResult emitOMPTileDirective(const OMPTileDirective &s)
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.
void emitOMPRequiresDecl(const OMPRequiresDecl &d)
VlaSizePair getVLASize(const VariableArrayType *type)
Returns an MLIR::Value+QualType pair that corresponds to the size, in non-variably-sized elements,...
LValue emitScalarCompoundAssignWithComplex(const CompoundAssignOperator *e, mlir::Value &result)
mlir::LogicalResult emitOMPTargetTeamsDirective(const OMPTargetTeamsDirective &s)
void populateEHCatchRegions(EHScopeStack::stable_iterator scope, cir::TryOp tryOp)
Address cxxDefaultInitExprThis
The value of 'this' to sue when evaluating CXXDefaultInitExprs within this expression.
Definition CIRGenFunction.h:148
void emitStaticVarDecl(const VarDecl &d, cir::GlobalLinkageKind linkage)
mlir::Value emitComplexExpr(const Expr *e)
Emit the computation of the specified expression of complex type, returning the result.
mlir::LogicalResult emitOMPTeamsDistributeParallelForDirective(const OMPTeamsDistributeParallelForDirective &s)
void exitCXXTryStmt(const CXXTryStmt &s, bool isFnTryBlock=false)
mlir::LogicalResult emitOMPBarrierDirective(const OMPBarrierDirective &s)
void setBeforeOutermostConditional(mlir::Value value, Address addr)
Definition CIRGenFunction.h:1918
mlir::LogicalResult emitOMPTargetParallelDirective(const OMPTargetParallelDirective &s)
mlir::LogicalResult emitOpenACCCacheConstruct(const OpenACCCacheConstruct &s)
mlir::Value loadCXXThis()
Load the value for 'this'.
Definition CIRGenFunction.h:910
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())
void emitDeleteCall(const FunctionDecl *deleteFD, mlir::Value ptr, QualType deleteTy)
LValue emitMemberExpr(const MemberExpr *e)
clang::CharUnits cxxThisAlignment
Definition CIRGenFunction.h:139
const TargetInfo & getTarget() const
Definition CIRGenFunction.h:243
void replaceAddrOfLocalVar(const clang::VarDecl *vd, Address addr)
Definition CIRGenFunction.h:720
llvm::DenseMap< const clang::Decl *, Address > DeclMapTy
Definition CIRGenFunction.h:163
LValue emitConditionalOperatorLValue(const AbstractConditionalOperator *expr)
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.
Definition CIRGenFunction.h:847
const clang::Decl * curFuncDecl
Definition CIRGenFunction.h:151
mlir::LogicalResult emitOMPTargetDirective(const OMPTargetDirective &s)
mlir::LogicalResult emitCXXForRangeStmt(const CXXForRangeStmt &s, llvm::ArrayRef< const Attr * > attrs)
Address loadCXXThisAddress()
LValue emitLValueForLambdaField(const FieldDecl *field)
RValue emitCall(const CIRGenFunctionInfo &funcInfo, const CIRGenCallee &callee, ReturnValueSlot returnValue, const CallArgList &args, cir::CIRCallOpInterface *callOrTryCall=nullptr)
Definition CIRGenFunction.h:1416
mlir::Value evaluateExprAsBool(const clang::Expr *e)
Perform the usual unary conversions on the specified expression and compare the result against zero,...
bool isTrivialInitializer(const Expr *init)
Determine whether the given initializer is trivial in the sense that it requires no code to be genera...
void emitOpenACCDeclare(const OpenACCDeclareDecl &d)
Address getAddrOfLocalVar(const clang::VarDecl *vd)
Return the address of a local variable.
Definition CIRGenFunction.h:889
void emitAnyExprToExn(const Expr *e, Address addr)
void emitAggregateCopy(LValue dest, LValue src, QualType eltTy, AggValueSlot::Overlap_t mayOverlap, bool isVolatile=false)
Emit an aggregate copy.
std::string getCounterRefTmpAsString()
LValue makeNaturalAlignAddrLValue(mlir::Value val, QualType ty)
llvm::DenseMap< const Expr *, mlir::Value > vlaSizeMap
Definition CIRGenFunction.h:264
CGCoroInfo curCoro
Definition CIRGenFunction.h:113
bool constantFoldsToSimpleInteger(const clang::Expr *cond, llvm::APSInt &resultInt, bool allowLabels=false)
If the specified expression does not fold to a constant, or if it does fold but contains a label,...
CIRGenModule & cgm
Definition CIRGenFunction.h:55
Address getAsNaturalAddressOf(Address addr, QualType pointeeTy)
JumpDest returnBlock(mlir::Block *retBlock)
Unified return block.
Definition CIRGenFunction.h:96
LValue emitComplexCompoundAssignmentLValue(const CompoundAssignOperator *e)
mlir::LogicalResult emitOMPScopeDirective(const OMPScopeDirective &s)
mlir::Value getVTTParameter(GlobalDecl gd, bool forVirtualBase, bool delegating)
Return the VTT parameter that should be passed to a base constructor/destructor with virtual bases.
mlir::Location getLoc(clang::SourceLocation srcLoc)
Helpers to convert Clang's SourceLocation to a MLIR Location.
mlir::LogicalResult emitOMPDepobjDirective(const OMPDepobjDirective &s)
void initializeVTablePointers(mlir::Location loc, const clang::CXXRecordDecl *rd)
mlir::Type convertType(const TypeDecl *t)
Definition CIRGenFunction.h:206
bool constantFoldsToBool(const clang::Expr *cond, bool &resultBool, bool allowLabels=false)
If the specified expression does not fold to a constant, or if it does but contains a label,...
mlir::Value emitOpOnBoolExpr(mlir::Location loc, const clang::Expr *cond)
TODO(cir): see EmitBranchOnBoolExpr for extra ideas).
void initializeVTablePointer(mlir::Location loc, const VPtr &vptr)
Address getAddressOfBaseClass(Address value, const CXXRecordDecl *derived, llvm::iterator_range< CastExpr::path_const_iterator > path, bool nullCheckValue, SourceLocation loc)
void emitOMPDeclareReduction(const OMPDeclareReductionDecl &d)
void emitAggregateStore(mlir::Value value, Address dest)
mlir::LogicalResult emitReturnStmt(const clang::ReturnStmt &s)
LValue emitLoadOfReferenceLValue(Address refAddr, mlir::Location loc, QualType refTy, AlignmentSource source)
void emitDelegateCXXConstructorCall(const clang::CXXConstructorDecl *ctor, clang::CXXCtorType ctorType, const FunctionArgList &args, clang::SourceLocation loc)
VlaSizePair getVLAElements1D(const VariableArrayType *vla)
Return the number of elements for a single dimension for the given array type.
mlir::Value emitScalarPrePostIncDec(const UnaryOperator *e, LValue lv, cir::UnaryOpKind kind, bool isPre)
ConditionalEvaluation * outermostConditional
Definition CIRGenFunction.h:1933
mlir::LogicalResult emitOpenACCInitConstruct(const OpenACCInitConstruct &s)
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.
RValue emitCXXMemberOrOperatorCall(const clang::CXXMethodDecl *md, const CIRGenCallee &callee, ReturnValueSlot returnValue, mlir::Value thisPtr, mlir::Value implicitParam, clang::QualType implicitParamTy, const clang::CallExpr *ce, CallArgList *rtlArgs)
LValue getOrCreateOpaqueLValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its LValue mapping if it exists, otherwise create one.
mlir::LogicalResult emitOMPDistributeParallelForSimdDirective(const OMPDistributeParallelForSimdDirective &s)
void emitBaseInitializer(mlir::Location loc, const CXXRecordDecl *classDecl, CXXCtorInitializer *baseInit)
RValue emitAtomicExpr(AtomicExpr *e)
bool isCoroutine() const
Definition CIRGenFunction.h:115
void emitExprAsInit(const clang::Expr *init, const clang::ValueDecl *d, LValue lvalue, bool capturedByInit=false)
Emit an expression as an initializer for an object (variable, field, etc.) at the given location.
mlir::LogicalResult emitCXXTryStmtUnderScope(const clang::CXXTryStmt &s)
mlir::LogicalResult emitOMPUnrollDirective(const OMPUnrollDirective &s)
mlir::Value emitArrayLength(const clang::ArrayType *arrayType, QualType &baseType, Address &addr)
Computes the length of an array in elements, as well as the base element type and a properly-typed fi...
void emitNullInitialization(mlir::Location loc, Address destPtr, QualType ty)
mlir::LogicalResult emitOMPTaskDirective(const OMPTaskDirective &s)
mlir::LogicalResult emitOpenACCSetConstruct(const OpenACCSetConstruct &s)
RValue emitReferenceBindingToExpr(const Expr *e)
Emits a reference binding to the passed in expression.
void emitVAStart(mlir::Value vaList, mlir::Value count)
Emits the start of a CIR variable-argument operation (cir.va_start)
mlir::LogicalResult emitOMPTeamsGenericLoopDirective(const OMPTeamsGenericLoopDirective &s)
VPtrsVector getVTablePointers(const clang::CXXRecordDecl *vtableClass)
const TargetCIRGenInfo & getTargetHooks() const
Definition CIRGenFunction.h:246
mlir::LogicalResult emitOMPCanonicalLoop(const OMPCanonicalLoop &s)
mlir::LogicalResult emitSwitchStmt(const clang::SwitchStmt &s)
mlir::Value evaluateOrEmitBuiltinObjectSize(const clang::Expr *e, unsigned type, cir::IntType resType, mlir::Value emittedE, bool isDynamic)
mlir::LogicalResult emitOMPTeamsDirective(const OMPTeamsDirective &s)
JumpDest getJumpDestInCurrentScope(mlir::Block *target)
The given basic block lies in the current EH scope, but may be a target of a potentially scope-crossi...
Definition CIRGenFunction.h:657
mlir::LogicalResult emitCaseStmt(const clang::CaseStmt &s, mlir::Type condType, bool buildingTopLevelCase)
LValue emitArraySubscriptExpr(const clang::ArraySubscriptExpr *e)
llvm::ScopedHashTableScope< const clang::Decl *, mlir::Value > SymTableScopeTy
Definition CIRGenFunction.h:449
OpenACCDataOperandInfo getOpenACCDataOperandInfo(const Expr *e)
mlir::LogicalResult emitOMPMaskedTaskLoopDirective(const OMPMaskedTaskLoopDirective &s)
CleanupKind getCleanupKind(QualType::DestructionKind kind)
Definition CIRGenFunction.h:701
mlir::Value emitBuiltinObjectSize(const clang::Expr *e, unsigned type, cir::IntType resType, mlir::Value emittedE, bool isDynamic)
Returns a Value corresponding to the size of the given expression by emitting a cir....
mlir::LogicalResult emitOMPFuseDirective(const OMPFuseDirective &s)
AggValueSlot::Overlap_t getOverlapForFieldInit(const FieldDecl *fd)
mlir::LogicalResult emitSimpleStmt(const clang::Stmt *s, bool useCurrentScope)
mlir::LogicalResult emitOMPSectionDirective(const OMPSectionDirective &s)
mlir::Block * indirectGotoBlock
IndirectBranch - The first time an indirect goto is seen we create a block reserved for the indirect ...
Definition CIRGenFunction.h:665
mlir::Operation * curFn
The current function or global initializer that is generated code for.
Definition CIRGenFunction.h:158
mlir::LogicalResult emitAsmStmt(const clang::AsmStmt &s)
Address emitExtVectorElementLValue(LValue lv, mlir::Location loc)
Generates lvalue for partial ext_vector access.
mlir::LogicalResult emitOMPParallelForSimdDirective(const OMPParallelForSimdDirective &s)
void emitOMPAllocateDecl(const OMPAllocateDecl &d)
mlir::LogicalResult emitOMPDistributeParallelForDirective(const OMPDistributeParallelForDirective &s)
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...
Address getAddressOfDerivedClass(mlir::Location loc, Address baseAddr, const CXXRecordDecl *derived, llvm::iterator_range< CastExpr::path_const_iterator > path, bool nullCheckValue)
std::optional< mlir::Value > emitTargetBuiltinExpr(unsigned builtinID, const clang::CallExpr *e, ReturnValueSlot &returnValue)
mlir::Value emitPromotedComplexExpr(const Expr *e, QualType promotionType)
ImplicitParamDecl * cxxStructorImplicitParamDecl
When generating code for a constructor or destructor, this will hold the implicit argument (e....
Definition CIRGenFunction.h:143
mlir::LogicalResult emitOpenACCComputeConstruct(const OpenACCComputeConstruct &s)
void emitOMPDeclareMapper(const OMPDeclareMapperDecl &d)
mlir::LogicalResult emitOMPMasterTaskLoopSimdDirective(const OMPMasterTaskLoopSimdDirective &s)
EHScopeStack ehStack
Tracks function scope overall cleanup handling.
Definition CIRGenFunction.h:122
void enterDtorCleanups(const CXXDestructorDecl *dtor, CXXDtorType type)
Enter the cleanups necessary to complete the given phase of destruction for a destructor.
llvm::SmallVector< const ParmVarDecl * > fnArgs
Save Parameter Decl for coroutine.
Definition CIRGenFunction.h:161
mlir::Value emitUnPromotedValue(mlir::Value result, QualType unPromotionType)
cir::CallOp emitCoroEndBuiltinCall(mlir::Location loc, mlir::Value nullPtr)
mlir::LogicalResult emitSwitchBody(const clang::Stmt *s)
mlir::LogicalResult emitForStmt(const clang::ForStmt &s)
AggValueSlot createAggTemp(QualType ty, mlir::Location loc, const Twine &name="tmp", Address *alloca=nullptr)
Create a temporary memory object for the given aggregate type.
Definition CIRGenFunction.h:2279
void populateCatchHandlersIfRequired(cir::TryOp tryOp)
void emitNewArrayInitializer(const CXXNewExpr *e, QualType elementType, mlir::Type elementTy, Address beginPtr, mlir::Value numElements, mlir::Value allocSizeWithoutCookie)
mlir::LogicalResult emitOMPTaskwaitDirective(const OMPTaskwaitDirective &s)
mlir::LogicalResult emitOMPFlushDirective(const OMPFlushDirective &s)
mlir::LogicalResult emitOMPGenericLoopDirective(const OMPGenericLoopDirective &s)
mlir::LogicalResult emitOMPTargetUpdateDirective(const OMPTargetUpdateDirective &s)
std::optional< mlir::Value > fnRetAlloca
The compiler-generated variable that holds the return value.
Definition CIRGenFunction.h:103
unsigned nextCleanupDestIndex
Definition CIRGenFunction.h:100
void emitImplicitAssignmentOperatorBody(FunctionArgList &args)
clang::SanitizerSet sanOpts
Sanitizers enabled for this function.
Definition CIRGenFunction.h:185
static int64_t getZExtIntValueFromConstOp(mlir::Value val)
Get zero-extended integer from a mlir::Value that is an int constant or a constant op.
Definition CIRGenFunction.h:219
mlir::LogicalResult emitOMPOrderedDirective(const OMPOrderedDirective &s)
mlir::LogicalResult emitOMPTargetParallelForSimdDirective(const OMPTargetParallelForSimdDirective &s)
mlir::LogicalResult emitOMPInterchangeDirective(const OMPInterchangeDirective &s)
RValue emitLoadOfExtVectorElementLValue(LValue lv)
mlir::LogicalResult emitOMPDispatchDirective(const OMPDispatchDirective &s)
mlir::Type convertTypeForMem(QualType t)
clang::QualType buildFunctionArgList(clang::GlobalDecl gd, FunctionArgList &args)
mlir::LogicalResult emitOMPParallelDirective(const OMPParallelDirective &s)
cir::CallOp emitCoroAllocBuiltinCall(mlir::Location loc)
RValue emitCoroutineFrame()
void emitCtorPrologue(const clang::CXXConstructorDecl *ctor, clang::CXXCtorType ctorType, FunctionArgList &args)
This routine generates necessary code to initialize base classes and non-static data members belongin...
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.
void populateUnwindResumeBlock(bool isCleanup, cir::TryOp tryOp)
mlir::Value createDummyValue(mlir::Location loc, clang::QualType qt)
void emitCXXConstructExpr(const clang::CXXConstructExpr *e, AggValueSlot dest)
mlir::Value emitLoadOfComplex(LValue src, SourceLocation loc)
Load a complex number from the specified l-value.
mlir::LogicalResult emitOMPForSimdDirective(const OMPForSimdDirective &s)
LValue emitAggExprToLValue(const Expr *e)
mlir::LogicalResult emitOMPTaskLoopDirective(const OMPTaskLoopDirective &s)
void emitStoreOfScalar(mlir::Value value, Address addr, bool isVolatile, clang::QualType ty, LValueBaseInfo baseInfo, bool isInit=false, bool isNontemporal=false)
void pushDestroy(QualType::DestructionKind dtorKind, Address addr, QualType type)
Push the standard destructor for the given type as at least a normal cleanup.
clang::CurrentSourceLocExprScope curSourceLocExprScope
Source location information about the default argument or member initializer expression we're evaluat...
Definition CIRGenFunction.h:790
mlir::Value loadCXXVTT()
Load the VTT parameter to base constructors/destructors have virtual bases.
Definition CIRGenFunction.h:919
void emitVarDecl(const clang::VarDecl &d)
This method handles emission of any variable declaration inside a function, including static vars etc...
static Destroyer destroyCXXObject
Definition CIRGenFunction.h:1243
LValue emitCompoundAssignmentLValue(const clang::CompoundAssignOperator *e)
mlir::Value emitCXXNewExpr(const CXXNewExpr *e)
RValue getUndefRValue(clang::QualType ty)
Get an appropriate 'undef' rvalue for the given type.
Address returnValue
The temporary alloca to hold the return value.
Definition CIRGenFunction.h:119
LValue makeAddrLValue(Address addr, QualType ty, LValueBaseInfo baseInfo)
Definition CIRGenFunction.h:878
static int64_t getSExtIntValueFromConstOp(mlir::Value val)
Get integer from a mlir::Value that is an int constant or a constant op.
Definition CIRGenFunction.h:211
mlir::LogicalResult emitOMPTargetDataDirective(const OMPTargetDataDirective &s)
std::optional< mlir::Value > emitX86BuiltinExpr(unsigned builtinID, const CallExpr *expr)
mlir::LogicalResult emitLabel(const clang::LabelDecl &d)
void emitCXXConstructorCall(const clang::CXXConstructorDecl *d, clang::CXXCtorType type, bool forVirtualBase, bool delegating, AggValueSlot thisAVS, const clang::CXXConstructExpr *e)
mlir::LogicalResult emitOMPTargetParallelGenericLoopDirective(const OMPTargetParallelGenericLoopDirective &s)
static bool hasAggregateEvaluationKind(clang::QualType type)
Definition CIRGenFunction.h:233
mlir::Value getVTablePtr(mlir::Location loc, Address thisAddr, const clang::CXXRecordDecl *vtableClass)
Return the Value of the vtable pointer member pointed to by thisAddr.
void emitArrayDestroy(mlir::Value begin, mlir::Value numElements, QualType elementType, CharUnits elementAlign, Destroyer *destroyer)
Destroys all the elements of the given array, beginning from last to first.
LValue emitPointerToDataMemberBinaryExpr(const BinaryOperator *e)
mlir::LogicalResult emitOMPParallelMaskedDirective(const OMPParallelMaskedDirective &s)
RValue emitAnyExprToTemp(const clang::Expr *e)
Similarly to emitAnyExpr(), however, the result will always be accessible even if no aggregate locati...
void finishFunction(SourceLocation endLoc)
mlir::LogicalResult emitOMPMaskedTaskLoopSimdDirective(const OMPMaskedTaskLoopSimdDirective &s)
mlir::LogicalResult emitOMPAtomicDirective(const OMPAtomicDirective &s)
mlir::LogicalResult emitOpenACCShutdownConstruct(const OpenACCShutdownConstruct &s)
mlir::LogicalResult emitFunctionBody(const clang::Stmt *body)
mlir::LogicalResult emitBreakStmt(const clang::BreakStmt &s)
mlir::Value emitComplexPrePostIncDec(const UnaryOperator *e, LValue lv, cir::UnaryOpKind op, bool isPre)
mlir::LogicalResult emitIndirectGotoStmt(const IndirectGotoStmt &s)
mlir::LogicalResult emitOMPTeamsDistributeParallelForSimdDirective(const OMPTeamsDistributeParallelForSimdDirective &s)
mlir::LogicalResult emitOMPTaskgroupDirective(const OMPTaskgroupDirective &s)
mlir::Value emitTernaryOnBoolExpr(const clang::Expr *cond, mlir::Location loc, const clang::Stmt *thenS, const clang::Stmt *elseS)
void emitStoreOfComplex(mlir::Location loc, mlir::Value v, LValue dest, bool isInit)
EmitStoreOfComplex - Store a complex number into the specified l-value.
llvm::SmallPtrSet< const clang::CXXRecordDecl *, 4 > VisitedVirtualBasesSetTy
Definition CIRGenFunction.h:768
mlir::LogicalResult emitOMPParallelMaskedTaskLoopSimdDirective(const OMPParallelMaskedTaskLoopSimdDirective &s)
mlir::LogicalResult emitOMPTeamsDistributeDirective(const OMPTeamsDistributeDirective &s)
void emitScalarInit(const clang::Expr *init, mlir::Location loc, LValue lvalue, bool capturedByInit=false)
std::string getCounterAggTmpAsString()
LValue emitUnaryOpLValue(const clang::UnaryOperator *e)
void emitReturnOfRValue(mlir::Location loc, RValue rv, QualType ty)
bool shouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *rd)
Returns whether we should perform a type checked load when loading a virtual function for virtual cal...
bool hasVolatileMember(QualType t)
returns true if aggregate type has a volatile member.
Definition CIRGenFunction.h:971
RValue emitLoadOfBitfieldLValue(LValue lv, SourceLocation loc)
mlir::LogicalResult emitOMPInteropDirective(const OMPInteropDirective &s)
RValue emitCall(const CIRGenFunctionInfo &funcInfo, const CIRGenCallee &callee, ReturnValueSlot returnValue, const CallArgList &args, cir::CIRCallOpInterface *callOp, mlir::Location loc)
mlir::LogicalResult emitOMPErrorDirective(const OMPErrorDirective &s)
SymTableTy symbolTable
Definition CIRGenFunction.h:193
LValue emitComplexAssignmentLValue(const BinaryOperator *e)
mlir::LogicalResult emitOMPSingleDirective(const OMPSingleDirective &s)
void emitCallArg(CallArgList &args, const clang::Expr *e, clang::QualType argType)
clang::FieldDecl * lambdaThisCaptureField
Definition CIRGenFunction.h:132
mlir::LogicalResult emitContinueStmt(const clang::ContinueStmt &s)
const clang::Decl * curCodeDecl
This is the inner-most code context, which includes blocks.
Definition CIRGenFunction.h:153
mlir::LogicalResult emitOMPTaskyieldDirective(const OMPTaskyieldDirective &s)
void emitConstructorBody(FunctionArgList &args)
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...
mlir::Value getAsNaturalPointerTo(Address addr, QualType pointeeType)
Definition CIRGenFunction.h:534
mlir::LogicalResult emitOMPTargetTeamsDistributeSimdDirective(const OMPTargetTeamsDistributeSimdDirective &s)
LValue emitCallExprLValue(const clang::CallExpr *e)
mlir::LogicalResult emitOMPScanDirective(const OMPScanDirective &s)
bool haveInsertPoint() const
True if an insertion point is defined.
Definition CIRGenFunction.h:470
llvm::SmallVector< mlir::Type, 2 > condTypeStack
The type of the condition for the emitting switch statement.
Definition CIRGenFunction.h:169
mlir::LogicalResult emitOMPTargetEnterDataDirective(const OMPTargetEnterDataDirective &s)
void emitAutoVarInit(const AutoVarEmission &emission)
Emit the initializer for an allocated variable.
void emitInitializerForField(clang::FieldDecl *field, LValue lhs, clang::Expr *init)
void emitStopPoint(const Stmt *s)
Build a debug stoppoint if we are emitting debug info.
std::optional< mlir::Value > emitAArch64BuiltinExpr(unsigned builtinID, const CallExpr *expr, ReturnValueSlot returnValue, llvm::Triple::ArchType arch)
void finishIndirectBranch()
void emitCXXTemporary(const CXXTemporary *temporary, QualType tempType, Address ptr)
Emits all the code to cause the given temporary to be cleaned up.
LValue emitStringLiteralLValue(const StringLiteral *e, llvm::StringRef name=".str")
mlir::LogicalResult emitOMPMasterTaskLoopDirective(const OMPMasterTaskLoopDirective &s)
void maybeEmitDeferredVarDeclInit(const VarDecl *vd)
void emitVAEnd(mlir::Value vaList)
Emits the end of a CIR variable-argument operation (cir.va_start)
mlir::Value emitToMemory(mlir::Value value, clang::QualType ty)
Given a value and its clang type, returns the value casted to its memory representation.
mlir::LogicalResult emitOpenACCHostDataConstruct(const OpenACCHostDataConstruct &s)
void resolveBlockAddresses()
std::optional< mlir::Value > emitAArch64SMEBuiltinExpr(unsigned builtinID, const CallExpr *expr)
LValue emitLValueForField(LValue base, const clang::FieldDecl *field)
mlir::Value emitScalarExpr(const clang::Expr *e, bool ignoreResultAssign=false)
Emit the computation of the specified expression of scalar type.
void pushStackRestore(CleanupKind kind, Address spMem)
mlir::LogicalResult emitIfStmt(const clang::IfStmt &s)
mlir::LogicalResult emitOMPForDirective(const OMPForDirective &s)
void emitAutoVarDecl(const clang::VarDecl &d)
Emit code and set up symbol table for a variable declaration with auto, register, or no storage class...
mlir::LogicalResult emitOMPMasterDirective(const OMPMasterDirective &s)
mlir::Value emitPromotedScalarExpr(const Expr *e, QualType promotionType)
AggValueSlot::Overlap_t getOverlapForReturnValue()
Determine whether a return value slot may overlap some other object.
Definition CIRGenFunction.h:932
cir::BrOp emitBranchThroughCleanup(mlir::Location loc, JumpDest dest)
Build a unconditional branch to the lexical scope cleanup block or with the labeled blocked if alread...
bool needsEHCleanup(QualType::DestructionKind kind)
Determines whether an EH cleanup is required to destroy a type with the given destruction kind.
Definition CIRGenFunction.h:686
mlir::LogicalResult emitSwitchCase(const clang::SwitchCase &s, bool buildingTopLevelCase)
Address emitLoadOfReference(LValue refLVal, mlir::Location loc, LValueBaseInfo *pointeeBaseInfo)
Address getAddressOfDirectBaseInCompleteClass(mlir::Location loc, Address value, const CXXRecordDecl *derived, const CXXRecordDecl *base, bool baseIsVirtual)
Convert the given pointer to a complete class to the given direct base.
bool shouldNullCheckClassCastValue(const CastExpr *ce)
mlir::LogicalResult emitOMPMetaDirective(const OMPMetaDirective &s)
mlir::LogicalResult emitOMPDistributeSimdDirective(const OMPDistributeSimdDirective &s)
CIRGenBuilderTy & getBuilder()
Definition CIRGenFunction.h:173
bool didCallStackSave
Whether a cir.stacksave operation has been added.
Definition CIRGenFunction.h:197
void emitDecl(const clang::Decl &d, bool evaluateConditionDecl=false)
mlir::LogicalResult emitOMPParallelGenericLoopDirective(const OMPParallelGenericLoopDirective &s)
LValue emitBinaryOperatorLValue(const BinaryOperator *e)
mlir::Value emitOpenACCIntExpr(const Expr *intExpr)
mlir::LogicalResult emitOMPMaskedDirective(const OMPMaskedDirective &s)
Address getAddrOfBitFieldStorage(LValue base, const clang::FieldDecl *field, mlir::Type fieldType, unsigned index)
AggValueSlot::Overlap_t getOverlapForBaseInit(const CXXRecordDecl *rd, const CXXRecordDecl *baseRD, bool isVirtual)
Determine whether a base class initialization may overlap some other object.
void emitDestroy(Address addr, QualType type, Destroyer *destroyer)
Immediately perform the destruction of the given object.
const CIRGenModule & getCIRGenModule() const
Definition CIRGenFunction.h:176
void startFunction(clang::GlobalDecl gd, clang::QualType returnType, cir::FuncOp fn, cir::FuncType funcType, FunctionArgList args, clang::SourceLocation loc, clang::SourceLocation startLoc)
Emit code for the start of a function.
llvm::DenseMap< const VarDecl *, mlir::Value > nrvoFlags
A mapping from NRVO variables to the flags used to indicate when the NRVO has been applied to this va...
Definition CIRGenFunction.h:128
CIRGenModule & getCIRGenModule()
Definition CIRGenFunction.h:175
unsigned counterRefTmp
Hold counters for incrementally naming temporaries.
Definition CIRGenFunction.h:453
mlir::MLIRContext & getMLIRContext()
Definition CIRGenFunction.h:244
mlir::LogicalResult emitOpenACCEnterDataConstruct(const OpenACCEnterDataConstruct &s)
Destroyer * getDestroyer(clang::QualType::DestructionKind kind)
void Destroyer(CIRGenFunction &cgf, Address addr, QualType ty)
Definition CIRGenFunction.h:1241
void emitDestructorBody(FunctionArgList &args)
Emits the body of the current destructor.
void emitAtomicInit(Expr *init, LValue dest)
unsigned counterAggTmp
Definition CIRGenFunction.h:454
LValue emitCastLValue(const CastExpr *e)
Casts are never lvalues unless that cast is to a reference type.
mlir::LogicalResult emitOMPTargetExitDataDirective(const OMPTargetExitDataDirective &s)
mlir::Value emitLoadOfScalar(LValue lvalue, SourceLocation loc)
EmitLoadOfScalar - Load a scalar value from an address, taking care to appropriately convert from the...
mlir::LogicalResult emitCXXTryStmt(const clang::CXXTryStmt &s)
bool containsLabel(const clang::Stmt *s, bool ignoreCaseStmts=false)
Return true if the statement contains a label in it.
DeclMapTy localDeclMap
This keeps track of the CIR allocas or globals for local C declarations.
Definition CIRGenFunction.h:166
mlir::Value createOpenACCConstantInt(mlir::Location loc, unsigned width, int64_t value)
LValue emitDeclRefLValue(const clang::DeclRefExpr *e)
mlir::LogicalResult emitOMPTargetTeamsDistributeParallelForDirective(const OMPTargetTeamsDistributeParallelForDirective &s)
void emitComplexExprIntoLValue(const Expr *e, LValue dest, bool isInit)
void emitOMPThreadPrivateDecl(const OMPThreadPrivateDecl &d)
mlir::Value emitRuntimeCall(mlir::Location loc, cir::FuncOp callee, llvm::ArrayRef< mlir::Value > args={})
void emitOMPGroupPrivateDecl(const OMPGroupPrivateDecl &d)
llvm::DenseMap< const clang::ValueDecl *, clang::FieldDecl * > lambdaCaptureFields
Definition CIRGenFunction.h:131
mlir::LogicalResult emitOMPParallelForDirective(const OMPParallelForDirective &s)
RValue emitCoawaitExpr(const CoawaitExpr &e, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
ConstantEmission tryEmitAsConstant(const DeclRefExpr *refExpr)
Try to emit a reference to the given value without producing it as an l-value.
mlir::Value emitAlignmentAssumption(mlir::Value ptrValue, QualType ty, SourceLocation loc, SourceLocation assumptionLoc, int64_t alignment, mlir::Value offsetValue=nullptr)
mlir::LogicalResult emitCaseDefaultCascade(const T *stmt, mlir::Type condType, mlir::ArrayAttr value, cir::CaseOpKind kind, bool buildingTopLevelCase)
void emitCXXThrowExpr(const CXXThrowExpr *e)
mlir::LogicalResult emitOMPSectionsDirective(const OMPSectionsDirective &s)
LValue makeAddrLValue(Address addr, QualType ty, AlignmentSource source=AlignmentSource::Type)
Definition CIRGenFunction.h:873
int64_t getAccessedFieldNo(unsigned idx, mlir::ArrayAttr elts)
LValue emitPredefinedLValue(const PredefinedExpr *e)
bool isCatchOrCleanupRequired()
mlir::LogicalResult emitOMPDistributeDirective(const OMPDistributeDirective &s)
RValue emitAnyExpr(const clang::Expr *e, AggValueSlot aggSlot=AggValueSlot::ignored(), bool ignoreResult=false)
Emit code to compute the specified expression which can have any type.
mlir::LogicalResult emitOMPTargetTeamsDistributeParallelForSimdDirective(const OMPTargetTeamsDistributeParallelForSimdDirective &s)
void emitCXXDestructorCall(const CXXDestructorDecl *dd, CXXDtorType type, bool forVirtualBase, bool delegating, Address thisAddr, QualType thisTy)
mlir::LogicalResult emitOMPTargetTeamsGenericLoopDirective(const OMPTargetTeamsGenericLoopDirective &s)
llvm::SmallVector< VPtr, 4 > VPtrsVector
Definition CIRGenFunction.h:771
void emitLambdaStaticInvokeBody(const CXXMethodDecl *md)
bool sawAsmBlock
Whether or not a Microsoft-style asm block has been processed within this fuction.
Definition CIRGenFunction.h:201
mlir::LogicalResult emitDeclStmt(const clang::DeclStmt &s)
mlir::LogicalResult emitOMPTeamsDistributeSimdDirective(const OMPTeamsDistributeSimdDirective &s)
llvm::DenseMap< const OpaqueValueExpr *, RValue > opaqueRValues
Definition CIRGenFunction.h:256
RValue emitNewOrDeleteBuiltinCall(const FunctionProtoType *type, const CallExpr *callExpr, OverloadedOperatorKind op)
mlir::LogicalResult emitDefaultStmt(const clang::DefaultStmt &s, mlir::Type condType, bool buildingTopLevelCase)
mlir::LogicalResult emitWhileStmt(const clang::WhileStmt &s)
void instantiateIndirectGotoBlock()
mlir::LogicalResult emitLabelStmt(const clang::LabelStmt &s)
Address emitArrayToPointerDecay(const Expr *e, LValueBaseInfo *baseInfo=nullptr)
EHScopeStack::stable_iterator currentCleanupStackDepth
Definition CIRGenFunction.h:1054
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.
void pushFullExprCleanup(CleanupKind kind, As... a)
Push a cleanup to be run at the end of the current full-expression.
Definition CIRGenFunction.h:997
void emitDelegateCallArg(CallArgList &args, const clang::VarDecl *param, clang::SourceLocation loc)
We are performing a delegate call; that is, the current function is delegating to another one.
mlir::LogicalResult emitOMPTaskLoopSimdDirective(const OMPTaskLoopSimdDirective &s)
LexicalScope * curLexScope
Definition CIRGenFunction.h:1239
void emitAtomicStore(RValue rvalue, LValue dest, bool isInit)
mlir::Value emitStoreThroughBitfieldLValue(RValue src, LValue dstresult)
llvm::DenseMap< const OpaqueValueExpr *, LValue > opaqueLValues
Keeps track of the current set of opaque value expressions.
Definition CIRGenFunction.h:255
CIRGenFunction(CIRGenModule &cgm, CIRGenBuilderTy &builder, bool suppressNewContext=false)
void populateCatchHandlers(cir::TryOp tryOp)
GlobalDecl curSEHParent
Definition CIRGenFunction.h:124
std::optional< mlir::Location > currSrcLoc
Use to track source locations across nested visitor traversals.
Definition CIRGenFunction.h:431
LValue emitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *e)
LValue emitExtVectorElementExpr(const ExtVectorElementExpr *e)
clang::ASTContext & getContext() const
Definition CIRGenFunction.h:171
RValue emitCXXMemberOrOperatorMemberCallExpr(const clang::CallExpr *ce, const clang::CXXMethodDecl *md, ReturnValueSlot returnValue, bool hasQualifier, clang::NestedNameSpecifier qualifier, bool isArrow, const clang::Expr *base)
void setAddrOfLocalVar(const clang::VarDecl *vd, Address addr)
Set the address of a local variable.
Definition CIRGenFunction.h:708
mlir::Value emitScalarConstant(const ConstantEmission &constant, Expr *e)
RValue emitBuiltinExpr(const clang::GlobalDecl &gd, unsigned builtinID, const clang::CallExpr *e, ReturnValueSlot returnValue)
void emitCXXDeleteExpr(const CXXDeleteExpr *e)
mlir::LogicalResult emitCoroutineBody(const CoroutineBodyStmt &s)
RValue emitCXXOperatorMemberCallExpr(const CXXOperatorCallExpr *e, const CXXMethodDecl *md, ReturnValueSlot returnValue)
mlir::LogicalResult emitCompoundStmt(const clang::CompoundStmt &s, Address *lastValue=nullptr, AggValueSlot slot=AggValueSlot::ignored())
void emitNullabilityCheck(LValue lhs, mlir::Value rhs, clang::SourceLocation loc)
Given an assignment *lhs = rhs, emit a test that checks if rhs is nonnull, if 1LHS is marked _Nonnull...
mlir::LogicalResult emitGotoStmt(const clang::GotoStmt &s)
std::optional< mlir::Value > emitAArch64SVEBuiltinExpr(unsigned builtinID, const CallExpr *expr)
cir::CallOp emitCoroBeginBuiltinCall(mlir::Location loc, mlir::Value coroframeAddr)
void emitOMPCapturedExpr(const OMPCapturedExprDecl &d)
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::LogicalResult emitOMPParallelMasterTaskLoopDirective(const OMPParallelMasterTaskLoopDirective &s)
mlir::Value cxxabiThisValue
Definition CIRGenFunction.h:137
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={})
void popCleanupBlocks(EHScopeStack::stable_iterator oldCleanupStackDepth)
Takes the old cleanup stack size and emits the cleanup blocks that have been added.
RValue getOrCreateOpaqueRValueMapping(const OpaqueValueExpr *e)
Given an opaque value expression, return its RValue mapping if it exists, otherwise create one.
mlir::LogicalResult emitOMPCancelDirective(const OMPCancelDirective &s)
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.
Address emitVAListRef(const Expr *e)
Build a "reference" to a va_list; this is either the address or the value of the expression,...
mlir::LogicalResult emitOMPStripeDirective(const OMPStripeDirective &s)
mlir::LogicalResult emitOMPTargetTeamsDistributeDirective(const OMPTargetTeamsDistributeDirective &s)
mlir::LogicalResult emitCompoundStmtWithoutScope(const clang::CompoundStmt &s, Address *lastValue=nullptr, AggValueSlot slot=AggValueSlot::ignored())
mlir::LogicalResult emitOMPParallelSectionsDirective(const OMPParallelSectionsDirective &s)
mlir::LogicalResult emitOpenACCExitDataConstruct(const OpenACCExitDataConstruct &s)
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 emitDelegatingCXXConstructorCall(const CXXConstructorDecl *ctor, const FunctionArgList &args)
mlir::Value emitDynamicCast(Address thisAddr, const CXXDynamicCastExpr *dce)
void emitAggExpr(const clang::Expr *e, AggValueSlot slot)
mlir::Value emitScalarOrConstFoldImmArg(unsigned iceArguments, unsigned idx, const Expr *argExpr)
ConditionalInfo emitConditionalBlocks(const AbstractConditionalOperator *e, const FuncTy &branchGenFunc)
mlir::Value emitAlloca(llvm::StringRef name, mlir::Type ty, mlir::Location loc, clang::CharUnits alignment, mlir::OpBuilder::InsertPoint ip, mlir::Value arraySize=nullptr)
mlir::LogicalResult emitOpenACCAtomicConstruct(const OpenACCAtomicConstruct &s)
mlir::LogicalResult emitOMPTargetSimdDirective(const OMPTargetSimdDirective &s)
mlir::LogicalResult emitOMPAssumeDirective(const OMPAssumeDirective &s)
void popCleanupBlock()
Pops a cleanup block.
mlir::Value emitVAArg(VAArgExpr *ve)
Generate code to get an argument from the passed in pointer and update it accordingly.
RValue emitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *expr)
LValue emitCompoundLiteralLValue(const CompoundLiteralExpr *e)
void emitAutoVarCleanups(const AutoVarEmission &emission)
RValue emitRotate(const CallExpr *e, bool isRotateLeft)
mlir::LogicalResult emitOpenACCLoopConstruct(const OpenACCLoopConstruct &s)
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.
This class organizes the cross-module state that is used while lowering AST types to CIR types.
A saved depth on the scope stack.
A stack of scopes which respond to exceptions, including cleanups and catch blocks.
Type for representing both the decl and type of parameters to a function.
static LValue makeAddr(Address address, clang::QualType t, LValueBaseInfo baseInfo)
This trivial value class is used to represent the result of an expression that is evaluated.
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.
Represents a C++ constructor within a class.
Represents a C++ base or member initializer.
A default argument (C++ [dcl.fct.default]).
A use of a default initializer in a constructor or in aggregate initialization.
Represents a delete expression for memory deallocation and destructor calls, e.g.
Represents a C++ destructor within a class.
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
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.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
A call to an overloaded operator written using operator syntax.
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Represents a C++ struct/union/class.
Represents a C++ temporary.
A C++ throw-expression (C++ [except.throw]).
CXXTryStmt - A C++ try block, including all handlers.
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
CaseStmt - Represent a case statement.
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
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...
Represents a 'co_await' expression.
CompoundAssignOperator - For compound assignments (e.g.
CompoundLiteralExpr - [C99 6.5.2.5].
CompoundStmt - This represents a group of statements like { stmt stmt }.
ContinueStmt - This represents a continue.
Represents the body of a coroutine.
SourceLocExprScopeGuard(const Expr *DefaultExpr, CurrentSourceLocExprScope &Current)
Represents the current source location and context used to determine the value of the source location...
A reference to a declared variable, function, enum, etc.
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Decl - This represents one declaration (or definition), e.g.
DoStmt - This represents a 'do/while' stmt.
This represents one expression.
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Represents a member of a struct/union/class.
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Represents a function declaration or definition.
Represents a prototype with parameter type info, e.g.
GlobalDecl - represents a global declaration.
GotoStmt - This represents a direct goto.
IfStmt - This represents an if/then/else.
IndirectGotoStmt - This represents an indirect goto.
Represents the declaration of a label.
LabelStmt - Represents a label, which has a substatement.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
A pointer to member type per C++ 8.3.3 - Pointers to members.
Represents a C++ nested name specifier, such as "\::std::vector::".
ObjCMethodDecl - Represents an instance or class method declaration.
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 ...
Represents a parameter to a function.
[C99 6.4.2.2] - A predefined identifier such as func.
A (possibly-)qualified type.
@ DK_objc_strong_lifetime
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
The collection of all-type qualifiers we support.
ReturnStmt - This represents a return, optionally of an expression: return; return 4;.
Encodes a location in the source.
A trivial tuple used to represent a source range.
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...
SwitchStmt - This represents a 'switch' stmt.
Exposes information about the current target.
Represents a declaration of a type.
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Represents a call to the builtin function __builtin_va_arg.
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.
Represents a C array with a specified size that is not an integer-constant-expression.
WhileStmt - This represents a 'while' stmt.
AlignmentSource
The source of the alignment of an l-value; an expression of confidence in the alignment actually matc...
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
@ NormalCleanup
Denotes a cleanup that should run when a scope is exited using normal control flow (falling off the e...
const internal::VariadicDynCastAllOfMatcher< Stmt, CallExpr > callExpr
Matches call expressions.
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const AstTypeMatcher< ArrayType > arrayType
const internal::VariadicAllOfMatcher< Stmt > stmt
Matches statements.
const internal::VariadicDynCastAllOfMatcher< Stmt, Expr > expr
Matches expressions.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
CXXCtorType
C++ constructor types.
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
OpenACCComputeConstruct(OpenACCDirectiveKind K, SourceLocation Start, SourceLocation DirectiveLoc, SourceLocation End, ArrayRef< const OpenACCClause * > Clauses, Stmt *StructuredBlock)
const FunctionProtoType * T
CXXDtorType
C++ destructor types.
Definition CIRGenFunction.h:44
static bool aggValueSlot()
static bool peepholeProtection()
static bool opAllocaEscapeByReference()
static bool generateDebugInfo()
Definition CIRGenFunction.h:618
Definition CIRGenFunction.h:596
bool wasEmittedAsGlobal() const
Definition CIRGenFunction.h:626
AutoVarEmission(const clang::VarDecl &variable)
Definition CIRGenFunction.h:621
bool isEscapingByRef
True if the variable is a __block variable that is captured by an escaping block.
Definition CIRGenFunction.h:610
Address addr
The address of the alloca for languages with explicit address space (e.g.
Definition CIRGenFunction.h:602
bool emittedAsOffload
True if the variable was emitted as an offload recipe, and thus doesn't have the same sort of alloca ...
Definition CIRGenFunction.h:614
const clang::VarDecl * variable
Definition CIRGenFunction.h:597
mlir::Value nrvoFlag
Definition CIRGenFunction.h:616
AutoVarEmission(Invalid)
Definition CIRGenFunction.h:619
bool isConstantAggregate
True if the variable is of aggregate type and has a constant initializer.
Definition CIRGenFunction.h:606
Address getAllocatedAddress() const
Returns the raw, allocated address, which is not necessarily the address of the object itself.
Definition CIRGenFunction.h:633
bool wasEmittedAsOffloadClause() const
Definition CIRGenFunction.h:628
void setAllocatedAddress(Address a)
Definition CIRGenFunction.h:638
Address getObjectAddress(CIRGenFunction &cgf) const
Returns the address of the object within this declaration.
Definition CIRGenFunction.h:643
static AutoVarEmission invalid()
Definition CIRGenFunction.h:624
Definition CIRGenFunction.h:108
std::unique_ptr< CGCoroData > data
Definition CIRGenFunction.h:109
CXXDefaultArgExprScope(CIRGenFunction &cfg, const CXXDefaultArgExpr *e)
Definition CIRGenFunction.h:836
Definition CIRGenFunction.h:1909
std::optional< LValue > rhs
Definition CIRGenFunction.h:1910
std::optional< LValue > lhs
Definition CIRGenFunction.h:1910
mlir::Value result
Definition CIRGenFunction.h:1911
Represents a scope, including function bodies, compound statements, and the substatements of if/while...
Definition CIRGenFunction.h:1060
void setAsGlobalInit()
Definition CIRGenFunction.h:1132
bool isTry()
Definition CIRGenFunction.h:1130
llvm::ArrayRef< mlir::Block * > getRetBlocks()
Definition CIRGenFunction.h:1202
mlir::Block * createCleanupBlock(mlir::OpBuilder &builder)
Definition CIRGenFunction.h:1157
mlir::Block * getOrCreateRetBlock(CIRGenFunction &cgf, mlir::Location loc)
Definition CIRGenFunction.h:1208
LexicalScope(CIRGenFunction &cgf, mlir::Location loc, mlir::Block *eb)
Definition CIRGenFunction.h:1096
void setAsTry(cir::TryOp op)
Definition CIRGenFunction.h:1135
mlir::Block * getEntryBlock()
Definition CIRGenFunction.h:1236
void updateRetLoc(mlir::Block *b, mlir::Location loc)
Definition CIRGenFunction.h:1204
mlir::Block * getCleanupBlock(mlir::OpBuilder &builder)
Definition CIRGenFunction.h:1153
bool isRegular()
Definition CIRGenFunction.h:1127
unsigned depth
Definition CIRGenFunction.h:1094
void restore()
Definition CIRGenFunction.h:1115
cir::TryOp getClosestTryParent()
void setRetVal(mlir::Value v)
Definition CIRGenFunction.h:1112
void setAsTernary()
Definition CIRGenFunction.h:1134
bool isTernary()
Definition CIRGenFunction.h:1129
cir::TryOp getTry()
Definition CIRGenFunction.h:1148
mlir::Block * getOrCreateCleanupBlock(mlir::OpBuilder &builder)
Definition CIRGenFunction.h:1141
mlir::Location getRetLoc(mlir::Block *b)
Definition CIRGenFunction.h:1203
bool isGlobalInit()
Definition CIRGenFunction.h:1126
bool isSwitch()
Definition CIRGenFunction.h:1128
~LexicalScope()
Definition CIRGenFunction.h:1117
void setAsSwitch()
Definition CIRGenFunction.h:1133
Definition CIRGenFunction.h:2226
mlir::Value varValue
Definition CIRGenFunction.h:2228
std::string name
Definition CIRGenFunction.h:2229
QualType baseType
Definition CIRGenFunction.h:2234
llvm::SmallVector< mlir::Value > bounds
Definition CIRGenFunction.h:2235
llvm::SmallVector< QualType > boundTypes
Definition CIRGenFunction.h:2238
QualType origType
Definition CIRGenFunction.h:2233
mlir::Location beginLoc
Definition CIRGenFunction.h:2227
llvm::PointerUnion< const clang::FunctionProtoType *, const clang::ObjCMethodDecl * > p
Definition CIRGenFunction.h:479
PrototypeWrapper(const clang::ObjCMethodDecl *md)
Definition CIRGenFunction.h:482
PrototypeWrapper(const clang::FunctionProtoType *ft)
Definition CIRGenFunction.h:481
Definition CIRGenFunction.h:761
const clang::CXXRecordDecl * vtableClass
Definition CIRGenFunction.h:765
clang::CharUnits offsetFromNearestVBase
Definition CIRGenFunction.h:764
const clang::CXXRecordDecl * nearestVBase
Definition CIRGenFunction.h:763
clang::BaseSubobject base
Definition CIRGenFunction.h:762
mlir::Value numElts
Definition CIRGenFunction.h:515
QualType type
Definition CIRGenFunction.h:516
VlaSizePair(mlir::Value num, QualType ty)
Definition CIRGenFunction.h:518