29#include "mlir/IR/BuiltinOps.h"
30#include "mlir/IR/Location.h"
31#include "mlir/IR/MLIRContext.h"
32#include "mlir/IR/Verifier.h"
39 case TargetCXXABI::GenericItanium:
40 case TargetCXXABI::GenericAArch64:
41 case TargetCXXABI::AppleARM64:
44 case TargetCXXABI::Fuchsia:
45 case TargetCXXABI::GenericARM:
46 case TargetCXXABI::iOS:
47 case TargetCXXABI::WatchOS:
48 case TargetCXXABI::GenericMIPS:
49 case TargetCXXABI::WebAssembly:
50 case TargetCXXABI::XL:
51 case TargetCXXABI::Microsoft:
52 cgm.
errorNYI(
"C++ ABI kind not yet implemented");
56 llvm_unreachable(
"invalid C++ ABI kind");
59CIRGenModule::CIRGenModule(mlir::MLIRContext &mlirContext,
63 : builder(mlirContext, *this), astContext(astContext),
64 langOpts(astContext.
getLangOpts()), codeGenOpts(cgo),
65 theModule{
mlir::ModuleOp::create(
mlir::UnknownLoc::get(&mlirContext))},
66 diags(diags), target(astContext.getTargetInfo()),
67 abi(
createCXXABI(*this)), genTypes(*this), vtables(*this) {
97 const unsigned charSize = astContext.getTargetInfo().getCharWidth();
101 const unsigned sizeTypeSize =
102 astContext.getTypeSize(astContext.getSignedSizeType());
103 SizeAlignInBytes = astContext.toCharUnitsFromBits(sizeTypeSize).getQuantity();
110 std::optional<cir::SourceLanguage> sourceLanguage = getCIRSourceLanguage();
113 cir::CIRDialect::getSourceLanguageAttrName(),
114 cir::SourceLanguageAttr::get(&mlirContext, *sourceLanguage));
115 theModule->setAttr(cir::CIRDialect::getTripleAttrName(),
116 builder.getStringAttr(
getTriple().str()));
118 if (cgo.OptimizationLevel > 0 || cgo.OptimizeSize > 0)
119 theModule->setAttr(cir::CIRDialect::getOptInfoAttrName(),
120 cir::OptInfoAttr::get(&mlirContext,
121 cgo.OptimizationLevel,
126 FileID mainFileId = astContext.getSourceManager().getMainFileID();
128 *astContext.getSourceManager().getFileEntryForID(mainFileId);
131 theModule.setSymName(path);
132 theModule->setLoc(mlir::FileLineColLoc::get(&mlirContext, path,
148 auto &layout = astContext.getASTRecordLayout(rd);
153 return layout.getAlignment();
156 return layout.getNonVirtualAlignment();
170 if (
unsigned align = tt->getDecl()->getMaxAlignment()) {
173 return astContext.toCharUnitsFromBits(align);
179 t = astContext.getBaseElementType(t);
201 alignment = astContext.getTypeAlignInChars(t);
206 if (
unsigned maxAlign = astContext.getLangOpts().MaxTypeAlign) {
208 !astContext.isAlignmentRequired(t))
215 if (theTargetCIRGenInfo)
216 return *theTargetCIRGenInfo;
219 switch (triple.getArch()) {
226 case llvm::Triple::x86_64: {
227 switch (triple.getOS()) {
234 case llvm::Triple::Linux:
236 return *theTargetCIRGenInfo;
243 assert(cLoc.
isValid() &&
"expected valid source location");
247 return mlir::FileLineColLoc::get(builder.getStringAttr(filename),
252 assert(cRange.
isValid() &&
"expected a valid source range");
255 mlir::Attribute metadata;
256 return mlir::FusedLoc::get({begin, end}, metadata, builder.getContext());
265 false, isForDefinition);
299 assert(op &&
"expected a valid global op");
307 mlir::Operation *globalValueOp = op;
308 if (
auto gv = dyn_cast<cir::GetGlobalOp>(op))
310 mlir::SymbolTable::lookupSymbolIn(
getModule(), gv.getNameAttr());
312 if (
auto cirGlobalValue =
313 dyn_cast<cir::CIRGlobalValueInterface>(globalValueOp))
314 if (!cirGlobalValue.isDeclaration())
339 std::vector<GlobalDecl> curDeclsToEmit;
356 if (
const auto *cd = dyn_cast<clang::OpenACCConstructDecl>(gd.
getDecl())) {
363 if (
const auto *fd = dyn_cast<FunctionDecl>(global)) {
366 if (fd->hasAttr<AnnotateAttr>())
367 errorNYI(fd->getSourceRange(),
"deferredAnnotations");
368 if (!fd->doesThisDeclarationHaveABody()) {
369 if (!fd->doesDeclarationForceExternallyVisibleDefinition())
373 "function declaration that forces code gen");
378 assert(vd->isFileVarDecl() &&
"Cannot emit local var decl as global.");
380 !astContext.isMSStaticDataMemberInlineDefinition(vd)) {
384 if (astContext.getInlineVariableDefinitionKind(vd) ==
423 mlir::Operation *op) {
427 cir::FuncOp funcOp = dyn_cast_if_present<cir::FuncOp>(op);
428 if (!funcOp || funcOp.getFunctionType() != funcType) {
434 if (!funcOp.isDeclaration())
446 mlir::OpBuilder::InsertionGuard guard(builder);
451 setNonAliasAttributes(gd, funcOp);
454 if (funcDecl->getAttr<ConstructorAttr>())
455 errorNYI(funcDecl->getSourceRange(),
"constructor attribute");
456 if (funcDecl->getAttr<DestructorAttr>())
457 errorNYI(funcDecl->getSourceRange(),
"destructor attribute");
459 if (funcDecl->getAttr<AnnotateAttr>())
460 errorNYI(funcDecl->getSourceRange(),
"deferredAnnotations");
478 return mlir::SymbolTable::lookupSymbolIn(theModule, name);
482 mlir::Location loc, StringRef name,
483 mlir::Type t,
bool isConstant,
484 mlir::Operation *insertPoint) {
489 mlir::OpBuilder::InsertionGuard guard(builder);
495 builder.setInsertionPoint(insertPoint);
501 builder.setInsertionPointToStart(cgm.
getModule().getBody());
504 g = builder.create<cir::GlobalOp>(loc, name, t, isConstant);
510 mlir::SymbolTable::setSymbolVisibility(
511 g, mlir::SymbolTable::Visibility::Private);
518 if (isa_and_nonnull<NamedDecl>(d))
524void CIRGenModule::setNonAliasAttributes(
GlobalDecl gd, mlir::Operation *op) {
535std::optional<cir::SourceLanguage> CIRGenModule::getCIRSourceLanguage()
const {
537 using CIRLang = cir::SourceLanguage;
542 if (opts.C99 || opts.C11 || opts.C17 || opts.C23 || opts.C2y ||
543 opts.LangStd == ClangStd::lang_c89 ||
544 opts.LangStd == ClangStd::lang_gnu89)
549 errorNYI(
"CIR does not yet support the given source language");
561 gv.
setLinkage(cir::GlobalLinkageKind::ExternalWeakLinkage);
580 LangAS langAS,
const VarDecl *d,
597 if (entry.getSymType() == ty)
606 if (isForDefinition && !entry.isDeclaration()) {
615 if (!isForDefinition)
625 entry.getOperation());
640 if (langOpts.OpenMP && !langOpts.OpenMPSimd)
643 gv.setAlignmentAttr(
getSize(astContext.getDeclAlign(d)));
655 if (astContext.isMSStaticDataMemberInlineDefinition(d))
662 if (
getTriple().getArch() == llvm::Triple::xcore)
672 "external const declaration with initializer");
707 mlir::Type ptrTy = builder.getPointerTo(g.getSymType());
718 cir::PointerType ptrTy = builder.getPointerTo(globalOp.getSymType());
719 return builder.getGlobalViewAttr(ptrTy, globalOp);
732 bool isDefinitionAvailableExternally =
737 if (isDefinitionAvailableExternally &&
745 mlir::Attribute init;
746 bool needsGlobalCtor =
false;
747 bool needsGlobalDtor =
748 !isDefinitionAvailableExternally &&
753 std::optional<ConstantEmitter> emitter;
757 if (vd->
hasAttr<LoaderUninitializedAttr>()) {
760 }
else if (!initExpr) {
773 emitter.emplace(*
this);
774 mlir::Attribute initializer = emitter->tryEmitForInitializer(*initDecl);
784 if (!isDefinitionAvailableExternally)
785 needsGlobalCtor =
true;
799 if (mlir::isa<mlir::SymbolRefAttr>(init)) {
803 assert(mlir::isa<mlir::TypedAttr>(init) &&
"This should have a type");
804 auto typedInitAttr = mlir::cast<mlir::TypedAttr>(init);
805 initType = typedInitAttr.getType();
807 assert(!mlir::isa<mlir::NoneType>(initType) &&
"Should have a type by now");
813 if (!gv || gv.getSymType() != initType) {
820 if (vd->
hasAttr<AnnotateAttr>()) {
831 emitter->finalize(gv);
837 cir::GlobalLinkageKind linkage =
841 gv.setLinkage(linkage);
845 if (linkage == cir::GlobalLinkageKind::CommonLinkage)
848 setNonAliasAttributes(vd, gv);
855 if (needsGlobalCtor || needsGlobalDtor)
860 mlir::Operation *op) {
862 if (
const auto *fd = dyn_cast<FunctionDecl>(
decl)) {
866 if (
const auto *method = dyn_cast<CXXMethodDecl>(
decl)) {
870 abi->emitCXXStructor(gd);
871 else if (fd->isMultiVersion())
872 errorNYI(method->getSourceRange(),
"multiversion functions");
876 if (method->isVirtual())
882 if (fd->isMultiVersion())
883 errorNYI(fd->getSourceRange(),
"multiversion functions");
888 if (
const auto *vd = dyn_cast<VarDecl>(
decl))
891 llvm_unreachable(
"Invalid argument to CIRGenModule::emitGlobalDefinition");
905 astContext.getAsConstantArrayType(e->
getType());
906 uint64_t finalSize = cat->getZExtSize();
907 str.resize(finalSize);
909 mlir::Type eltTy =
convertType(cat->getElementType());
910 return builder.getString(str, eltTy, finalSize);
914 "getConstantArrayFromStringLiteral: wide characters");
915 return mlir::Attribute();
926 if (d.
hasAttr<SelectAnyAttr>())
930 if (
auto *vd = dyn_cast<VarDecl>(&d))
945 llvm_unreachable(
"No such linkage");
951 if (
auto globalOp = dyn_cast_or_null<cir::GlobalOp>(op)) {
952 globalOp.setComdat(
true);
955 funcOp.setComdat(
true);
961 genTypes.updateCompletedType(td);
965 replacements[name] = op;
968void CIRGenModule::replacePointerTypeArgs(cir::FuncOp oldF, cir::FuncOp newF) {
969 std::optional<mlir::SymbolTable::UseRange> optionalUseRange =
970 oldF.getSymbolUses(theModule);
971 if (!optionalUseRange)
974 for (
const mlir::SymbolTable::SymbolUse &u : *optionalUseRange) {
976 auto call = mlir::dyn_cast<cir::CallOp>(u.getUser());
980 for (
const auto [argOp, fnArgType] :
981 llvm::zip(call.getArgs(), newF.getFunctionType().getInputs())) {
982 if (argOp.getType() == fnArgType)
988 errorNYI(call.getLoc(),
"replace call with mismatched types");
993void CIRGenModule::applyReplacements() {
994 for (
auto &i : replacements) {
995 StringRef mangledName = i.first();
996 mlir::Operation *replacement = i.second;
1002 auto newF = dyn_cast<cir::FuncOp>(replacement);
1005 errorNYI(replacement->getLoc(),
"replacement is not a function");
1011 replacePointerTypeArgs(oldF, newF);
1014 if (oldF.replaceAllSymbolUses(newF.getSymNameAttr(), theModule).failed())
1015 llvm_unreachable(
"internal error, cannot RAUW symbol");
1017 newF->moveBefore(oldF);
1024 mlir::Location loc, StringRef name, mlir::Type ty,
1026 auto gv = mlir::dyn_cast_or_null<cir::GlobalOp>(
1027 mlir::SymbolTable::lookupSymbolIn(theModule, name));
1031 if (gv.getSymType() == ty)
1037 assert(gv.isDeclaration() &&
"Declaration has wrong type!");
1039 errorNYI(loc,
"createOrReplaceCXXRuntimeVariable: declaration exists with "
1050 mlir::SymbolTable::setSymbolVisibility(gv,
1054 !gv.hasAvailableExternallyLinkage()) {
1058 gv.setAlignmentAttr(
getSize(alignment));
1069 if ((noCommon || vd->
hasAttr<NoCommonAttr>()) && !vd->
hasAttr<CommonAttr>())
1080 if (vd->
hasAttr<SectionAttr>())
1086 if (vd->
hasAttr<PragmaClangBSSSectionAttr>() ||
1087 vd->
hasAttr<PragmaClangDataSectionAttr>() ||
1088 vd->
hasAttr<PragmaClangRelroSectionAttr>() ||
1089 vd->
hasAttr<PragmaClangRodataSectionAttr>())
1097 if (vd->
hasAttr<WeakImportAttr>())
1107 if (vd->
hasAttr<AlignedAttr>())
1114 for (
const FieldDecl *fd : rd->fields()) {
1115 if (fd->isBitField())
1117 if (fd->hasAttr<AlignedAttr>())
1142 return cir::GlobalLinkageKind::InternalLinkage;
1144 if (dd->
hasAttr<WeakAttr>()) {
1145 if (isConstantVariable)
1146 return cir::GlobalLinkageKind::WeakODRLinkage;
1147 return cir::GlobalLinkageKind::WeakAnyLinkage;
1152 return cir::GlobalLinkageKind::LinkOnceAnyLinkage;
1157 return cir::GlobalLinkageKind::AvailableExternallyLinkage;
1171 return !astContext.getLangOpts().AppleKext
1172 ? cir::GlobalLinkageKind::LinkOnceODRLinkage
1173 : cir::GlobalLinkageKind::InternalLinkage;
1187 return cir::GlobalLinkageKind::ExternalLinkage;
1190 return dd->
hasAttr<CUDAGlobalAttr>()
1191 ? cir::GlobalLinkageKind::ExternalLinkage
1192 : cir::GlobalLinkageKind::InternalLinkage;
1193 return cir::GlobalLinkageKind::WeakODRLinkage;
1202 return cir::GlobalLinkageKind::CommonLinkage;
1209 if (dd->
hasAttr<SelectAnyAttr>())
1210 return cir::GlobalLinkageKind::WeakODRLinkage;
1214 return cir::GlobalLinkageKind::ExternalLinkage;
1226 mlir::Operation *old, cir::FuncOp newFn) {
1228 auto oldFn = mlir::dyn_cast<cir::FuncOp>(old);
1236 if (oldFn->getAttrs().size() <= 1)
1238 "replaceUsesOfNonProtoTypeWithRealFunction: Attribute forwarding");
1241 newFn.setNoProto(oldFn.getNoProto());
1244 std::optional<mlir::SymbolTable::UseRange> symUses =
1245 oldFn.getSymbolUses(oldFn->getParentOp());
1246 for (
const mlir::SymbolTable::SymbolUse &use : symUses.value()) {
1247 mlir::OpBuilder::InsertionGuard guard(builder);
1249 if (
auto noProtoCallOp = mlir::dyn_cast<cir::CallOp>(use.getUser())) {
1250 builder.setInsertionPoint(noProtoCallOp);
1253 cir::CallOp realCallOp = builder.createCallOp(
1254 noProtoCallOp.getLoc(), newFn, noProtoCallOp.getOperands());
1257 noProtoCallOp.replaceAllUsesWith(realCallOp);
1258 noProtoCallOp.erase();
1259 }
else if (
auto getGlobalOp =
1260 mlir::dyn_cast<cir::GetGlobalOp>(use.getUser())) {
1262 getGlobalOp.getAddr().setType(
1263 cir::PointerType::get(newFn.getFunctionType()));
1266 "replaceUsesOfNonProtoTypeWithRealFunction: unexpected use");
1271cir::GlobalLinkageKind
1273 assert(!isConstant &&
"constant variables NYI");
1274 GVALinkage linkage = astContext.GetGVALinkageForVariable(vd);
1281 GVALinkage linkage = astContext.GetGVALinkageForFunction(d);
1283 if (
const auto *dtor = dyn_cast<CXXDestructorDecl>(d))
1292 StringRef globalName,
CharUnits alignment) {
1298 cgm, loc, globalName,
c.getType(), !cgm.
getLangOpts().WritableStrings);
1301 gv.setAlignmentAttr(cgm.
getSize(alignment));
1303 cir::GlobalLinkageKindAttr::get(cgm.
getBuilder().getContext(), lt));
1307 if (gv.isWeakForLinker()) {
1308 assert(cgm.
supportsCOMDAT() &&
"Only COFF uses weak string literals");
1311 cgm.
setDSOLocal(
static_cast<mlir::Operation *
>(gv));
1332 std::string result =
1335 assert(!mlir::SymbolTable::lookupSymbolIn(theModule, result));
1343 astContext.getAlignOfGlobalVarInChars(
s->getType(),
nullptr);
1351 if (!gv.getAlignment() ||
1352 uint64_t(alignment.
getQuantity()) > *gv.getAlignment())
1353 gv.setAlignmentAttr(
getSize(alignment));
1358 if (
getCXXABI().getMangleContext().shouldMangleStringLiteral(
s) &&
1361 "getGlobalForStringLiteral: mangle string literals");
1367 mlir::Location loc =
getLoc(
s->getSourceRange());
1368 auto typedC = llvm::cast<mlir::TypedAttr>(
c);
1370 cir::GlobalLinkageKind::PrivateLinkage, *
this,
1371 uniqueName, alignment);
1385 auto arrayTy = mlir::dyn_cast<cir::ArrayType>(gv.getSymType());
1386 assert(arrayTy &&
"String literal must be array");
1390 return builder.getGlobalViewAttr(ptrTy, gv);
1399 "emitExplicitCastExprType");
1409 if (
auto *oid = dyn_cast<ObjCImplDecl>(
decl))
1410 errorNYI(oid->getSourceRange(),
"emitDeclConext: ObjCImplDecl");
1420 if (
decl->isTemplated())
1423 switch (
decl->getKind()) {
1426 decl->getDeclKindName());
1429 case Decl::CXXConversion:
1430 case Decl::CXXMethod:
1431 case Decl::Function: {
1434 if (!fd->isConsteval())
1440 case Decl::Decomposition:
1441 case Decl::VarTemplateSpecialization: {
1444 errorNYI(
decl->getSourceRange(),
"global variable decompositions");
1450 case Decl::OpenACCRoutine:
1453 case Decl::OpenACCDeclare:
1458 case Decl::UsingDirective:
1459 case Decl::UsingEnum:
1460 case Decl::NamespaceAlias:
1462 case Decl::TypeAlias:
1468 case Decl::ClassTemplate:
1470 case Decl::CXXDeductionGuide:
1472 case Decl::FunctionTemplate:
1473 case Decl::StaticAssert:
1474 case Decl::TypeAliasTemplate:
1475 case Decl::UsingShadow:
1476 case Decl::VarTemplate:
1477 case Decl::VarTemplatePartialSpecialization:
1480 case Decl::CXXConstructor:
1483 case Decl::CXXDestructor:
1488 case Decl::LinkageSpec:
1489 case Decl::Namespace:
1493 case Decl::ClassTemplateSpecialization:
1494 case Decl::CXXRecord:
1499 case Decl::FileScopeAsm:
1501 if (langOpts.CUDA && langOpts.CUDAIsDevice)
1504 if (langOpts.OpenMPIsTargetDevice)
1507 if (langOpts.SYCLIsDevice)
1510 std::string line = file_asm->getAsmString();
1511 globalScopeAsm.push_back(builder.getStringAttr(line));
1518 op.setInitialValueAttr(value);
1532 md->getParent()->getNumVBases() == 0)
1534 "getAddrAndTypeOfCXXStructor: MS ABI complete destructor");
1545 false, isForDefinition);
1547 return {fnType, fn};
1551 mlir::Type funcType,
bool forVTable,
1555 "consteval function should never be emitted");
1565 if (
const auto *dd = dyn_cast<CXXDestructorDecl>(gd.
getDecl())) {
1568 dd->getParent()->getNumVBases() == 0)
1570 "getAddrOfFunction: MS ABI complete destructor");
1576 false, isForDefinition);
1584 llvm::raw_svector_ostream
out(buffer);
1593 assert(ii &&
"Attempt to mangle unnamed decl.");
1595 const auto *fd = dyn_cast<FunctionDecl>(nd);
1599 }
else if (fd && fd->hasAttr<CUDAGlobalAttr>() &&
1615 if (
const auto *fd = dyn_cast<FunctionDecl>(nd)) {
1616 if (fd->isMultiVersion()) {
1618 "getMangledName: multi-version functions");
1623 "getMangledName: GPU relocatable device code");
1626 return std::string(
out.str());
1634 if (
const auto *cd = dyn_cast<CXXConstructorDecl>(canonicalGd.
getDecl())) {
1637 "getMangledName: C++ constructor without variants");
1646 auto result = manglings.insert(std::make_pair(mangledName, gd));
1647 return mangledDeclNames[canonicalGd] = result.first->first();
1651 assert(!d->
getInit() &&
"Cannot emit definite definitions here!");
1659 if (gv && !mlir::cast<cir::GlobalOp>(gv).isDeclaration())
1675 if (langOpts.EmitAllDecls)
1678 const auto *vd = dyn_cast<VarDecl>(global);
1680 ((codeGenOpts.KeepPersistentStorageVariables &&
1681 (vd->getStorageDuration() ==
SD_Static ||
1682 vd->getStorageDuration() ==
SD_Thread)) ||
1683 (codeGenOpts.KeepStaticConsts && vd->getStorageDuration() ==
SD_Static &&
1684 vd->getType().isConstQualified())))
1697 if (langOpts.OpenMP >= 50 && !langOpts.OpenMPSimd) {
1698 std::optional<OMPDeclareTargetDeclAttr *> activeAttr =
1699 OMPDeclareTargetDeclAttr::getActiveAttr(global);
1700 if (!activeAttr || (*activeAttr)->getLevel() != (
unsigned)-1)
1704 const auto *fd = dyn_cast<FunctionDecl>(global);
1711 if (fd->hasAttr<TargetVersionAttr>() && !fd->isMultiVersion())
1713 if (langOpts.SYCLIsDevice) {
1714 errorNYI(fd->getSourceRange(),
"mayBeEmittedEagerly: SYCL");
1718 const auto *vd = dyn_cast<VarDecl>(global);
1720 if (astContext.getInlineVariableDefinitionKind(vd) ==
1728 if (langOpts.OpenMP && langOpts.OpenMPUseTLS &&
1729 astContext.getTargetInfo().isTLSSupported() &&
isa<VarDecl>(global) &&
1731 !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(global))
1734 assert((fd || vd) &&
1735 "Only FunctionDecl and VarDecl should hit this path so far.");
1740 cir::CIRGlobalValueInterface gv) {
1741 if (gv.hasLocalLinkage())
1744 if (!gv.hasDefaultVisibility() && !gv.hasExternalWeakLinkage())
1752 const llvm::Triple &tt = cgm.
getTriple();
1754 if (tt.isOSCygMing()) {
1763 cgm.
errorNYI(
"shouldAssumeDSOLocal: MinGW");
1769 if (tt.isOSBinFormatCOFF() && gv.hasExternalWeakLinkage())
1777 if (tt.isOSBinFormatCOFF() || (tt.isOSWindows() && tt.isOSBinFormatMachO()))
1781 if (!tt.isOSBinFormatELF())
1786 if (rm != llvm::Reloc::Static && !lOpts.PIE) {
1794 return !(lOpts.SemanticInterposition || lOpts.HalfNoSemanticInterposition);
1798 if (!gv.isDeclarationForLinker())
1804 if (rm == llvm::Reloc::PIC_ && gv.hasExternalWeakLinkage())
1811 if (cgOpts.DirectAccessExternalData) {
1817 if (
auto globalOp = dyn_cast<cir::GlobalOp>(gv.getOperation())) {
1850 if (
auto globalValue = dyn_cast<cir::CIRGlobalValueInterface>(op))
1869 bool isIncompleteFunction,
1889 StringRef mangledName, mlir::Type funcType,
GlobalDecl gd,
bool forVTable,
1891 mlir::ArrayAttr extraAttrs) {
1900 if (
const auto *fd = cast_or_null<FunctionDecl>(d)) {
1902 if (
getLangOpts().OpenMPIsTargetDevice && fd->isDefined() && !dontDefer &&
1905 "getOrCreateCIRFunction: OpenMP target function");
1909 if (fd->isMultiVersion())
1910 errorNYI(fd->getSourceRange(),
"getOrCreateCIRFunction: multi-version");
1916 assert(mlir::isa<cir::FuncOp>(entry));
1921 if (d && !d->
hasAttr<DLLImportAttr>() && !d->
hasAttr<DLLExportAttr>()) {
1929 if (isForDefinition && fn && !fn.isDeclaration()) {
1932 if (fn && fn.getFunctionType() == funcType) {
1936 if (!isForDefinition) {
1944 auto *funcDecl = llvm::cast_or_null<FunctionDecl>(gd.
getDecl());
1945 bool invalidLoc = !funcDecl ||
1946 funcDecl->getSourceRange().getBegin().isInvalid() ||
1947 funcDecl->getSourceRange().getEnd().isInvalid();
1949 invalidLoc ? theModule->getLoc() :
getLoc(funcDecl->getSourceRange()),
1950 mangledName, mlir::cast<cir::FuncType>(funcType), funcDecl);
1961 auto symbolOp = mlir::cast<mlir::SymbolOpInterface>(entry);
1969 if (symbolOp.getSymbolUses(symbolOp->getParentOp()))
1983 assert(funcOp.getFunctionType() == funcType);
1990 if (isa_and_nonnull<CXXDestructorDecl>(d) &&
2020 fd = fd->getPreviousDecl()) {
2022 if (fd->doesThisDeclarationHaveABody()) {
2035 cir::FuncType funcType,
2039 mlir::OpBuilder::InsertionGuard guard(builder);
2047 builder.setInsertionPoint(cgf->
curFn);
2049 func = builder.create<cir::FuncOp>(loc, name, funcType);
2054 func.setNoProto(
true);
2056 assert(func.isDeclaration() &&
"expected empty body");
2060 func.setLinkageAttr(cir::GlobalLinkageKindAttr::get(
2062 mlir::SymbolTable::setSymbolVisibility(
2063 func, mlir::SymbolTable::Visibility::Private);
2068 theModule.push_back(func);
2078 fnOp.setBuiltin(
true);
2082mlir::SymbolTable::Visibility
2086 if (op.isDeclaration())
2087 return mlir::SymbolTable::Visibility::Private;
2091mlir::SymbolTable::Visibility
2094 case cir::GlobalLinkageKind::InternalLinkage:
2095 case cir::GlobalLinkageKind::PrivateLinkage:
2096 return mlir::SymbolTable::Visibility::Private;
2097 case cir::GlobalLinkageKind::ExternalLinkage:
2098 case cir::GlobalLinkageKind::ExternalWeakLinkage:
2099 case cir::GlobalLinkageKind::LinkOnceODRLinkage:
2100 case cir::GlobalLinkageKind::AvailableExternallyLinkage:
2101 case cir::GlobalLinkageKind::CommonLinkage:
2102 case cir::GlobalLinkageKind::WeakAnyLinkage:
2103 case cir::GlobalLinkageKind::WeakODRLinkage:
2104 return mlir::SymbolTable::Visibility::Public;
2106 llvm::errs() <<
"visibility not implemented for '"
2107 << stringifyGlobalLinkageKind(glk) <<
"'\n";
2108 assert(0 &&
"not implemented");
2111 llvm_unreachable(
"linkage should be handled above!");
2115 clang::VisibilityAttr::VisibilityType visibility) {
2116 switch (visibility) {
2117 case clang::VisibilityAttr::VisibilityType::Default:
2118 return cir::VisibilityKind::Default;
2119 case clang::VisibilityAttr::VisibilityType::Hidden:
2120 return cir::VisibilityKind::Hidden;
2121 case clang::VisibilityAttr::VisibilityType::Protected:
2122 return cir::VisibilityKind::Protected;
2124 llvm_unreachable(
"unexpected visibility value");
2129 const clang::VisibilityAttr *va =
decl->getAttr<clang::VisibilityAttr>();
2130 cir::VisibilityAttr cirVisibility =
2133 cirVisibility = cir::VisibilityAttr::get(
2137 return cirVisibility;
2142 applyReplacements();
2144 theModule->setAttr(cir::CIRDialect::getModuleLevelAsmAttrName(),
2145 builder.getArrayAttr(globalScopeAsm));
2153 cir::FuncOp aliasee,
2154 cir::GlobalLinkageKind linkage) {
2156 auto *aliasFD = dyn_cast<FunctionDecl>(aliasGD.
getDecl());
2157 assert(aliasFD &&
"expected FunctionDecl");
2168 mangledName, fnType, aliasFD);
2169 alias.setAliasee(aliasee.getName());
2170 alias.setLinkage(linkage);
2174 mlir::SymbolTable::setSymbolVisibility(
2175 alias, mlir::SymbolTable::Visibility::Private);
2182 errorNYI(aliasFD->getSourceRange(),
"emitAliasForGlobal: previous uses");
2192 return genTypes.convertType(
type);
2199 return mlir::verify(theModule).succeeded();
2208 return builder.getConstNullPtrAttr(builder.getUInt8PtrTy());
2211 langOpts.ObjCRuntime.isGNUFamily()) {
2212 errorNYI(loc,
"getAddrOfRTTIDescriptor: Objc PtrType & Objc RT GUN");
2222 llvm::iterator_range<CastExpr::path_const_iterator> path) {
2229 assert(!base->isVirtual() &&
"Should not see virtual bases here!");
2234 const auto *baseDecl = base->getType()->castAsCXXRecordDecl();
2246 llvm::StringRef feature) {
2247 unsigned diagID = diags.getCustomDiagID(
2249 return diags.Report(loc, diagID) << feature;
2253 llvm::StringRef feature) {
Defines the clang::ASTContext interface.
static bool shouldAssumeDSOLocal(const CIRGenModule &cgm, cir::CIRGlobalValueInterface gv)
static bool shouldBeInCOMDAT(CIRGenModule &cgm, const Decl &d)
static std::string getMangledNameImpl(CIRGenModule &cgm, GlobalDecl gd, const NamedDecl *nd)
static cir::GlobalOp generateStringLiteral(mlir::Location loc, mlir::TypedAttr c, cir::GlobalLinkageKind lt, CIRGenModule &cgm, StringRef globalName, CharUnits alignment)
static CIRGenCXXABI * createCXXABI(CIRGenModule &cgm)
static bool isVarDeclStrongDefinition(const ASTContext &astContext, CIRGenModule &cgm, const VarDecl *vd, bool noCommon)
static void setLinkageForGV(cir::GlobalOp &gv, const NamedDecl *nd)
This file defines OpenACC nodes for declarative directives.
Defines the SourceManager interface.
__device__ __2f16 float __ockl_bool s
__device__ __2f16 float c
cir::PointerType getPointerTo(mlir::Type ty)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
@ Strong
Strong definition.
@ WeakUnknown
Weak for now, might become strong later in this TU.
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
bool isAlignmentRequired(const Type *T) const
Determine if the alignment the type has was required using an alignment attribute.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
GVALinkage GetGVALinkageForVariable(const VarDecl *VD) const
unsigned getTypeAlignIfKnown(QualType T, bool NeedsPreferredAlignment=false) const
Return the alignment of a type, in bits, or 0 if the type is incomplete and we cannot determine the a...
const TargetInfo & getTargetInfo() const
TargetCXXABI::Kind getCXXABIKind() const
Return the C++ ABI kind that should be used.
ASTRecordLayout - This class contains layout information for one RecordDecl, which is a struct/union/...
CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const
getBaseClassOffset - Get the offset, in chars, for the given base class.
Implements C++ ABI-specific code generation functions.
virtual mlir::Attribute getAddrOfRTTIDescriptor(mlir::Location loc, QualType ty)=0
virtual void emitCXXConstructors(const clang::CXXConstructorDecl *d)=0
Emit constructor variants required by this ABI.
virtual void emitCXXDestructors(const clang::CXXDestructorDecl *d)=0
Emit dtor variants required by this ABI.
clang::MangleContext & getMangleContext()
Gets the mangle context.
virtual cir::GlobalLinkageKind getCXXDestructorLinkage(GVALinkage linkage, const CXXDestructorDecl *dtor, CXXDtorType dt) const
cir::FuncOp generateCode(clang::GlobalDecl gd, cir::FuncOp fn, cir::FuncType funcType)
void emitVariablyModifiedType(QualType ty)
mlir::Operation * curFn
The current function or global initializer that is generated code for.
This class organizes the cross-function state that is used while generating CIR code.
void replaceUsesOfNonProtoTypeWithRealFunction(mlir::Operation *old, cir::FuncOp newFn)
This function is called when we implement a function with no prototype, e.g.
llvm::StringRef getMangledName(clang::GlobalDecl gd)
CharUnits computeNonVirtualBaseClassOffset(const CXXRecordDecl *derivedClass, llvm::iterator_range< CastExpr::path_const_iterator > path)
void setGlobalVisibility(mlir::Operation *op, const NamedDecl *d) const
Set the visibility for the given global.
DiagnosticBuilder errorNYI(SourceLocation, llvm::StringRef)
Helpers to emit "not yet implemented" error diagnostics.
void emitDeferred()
Emit any needed decls for which code generation was deferred.
clang::ASTContext & getASTContext() const
cir::FuncOp getAddrOfCXXStructor(clang::GlobalDecl gd, const CIRGenFunctionInfo *fnInfo=nullptr, cir::FuncType fnType=nullptr, bool dontDefer=false, ForDefinition_t isForDefinition=NotForDefinition)
void emitTopLevelDecl(clang::Decl *decl)
void addReplacement(llvm::StringRef name, mlir::Operation *op)
mlir::Type convertType(clang::QualType type)
bool shouldEmitRTTI(bool forEH=false)
cir::GlobalOp getGlobalForStringLiteral(const StringLiteral *s, llvm::StringRef name=".str")
Return a global symbol reference to a constant array for the given string literal.
bool mustBeEmitted(const clang::ValueDecl *d)
Determine whether the definition must be emitted; if this returns false, the definition can be emitte...
mlir::IntegerAttr getSize(CharUnits size)
CIRGenBuilderTy & getBuilder()
void setDSOLocal(mlir::Operation *op) const
std::string getUniqueGlobalName(const std::string &baseName)
std::pair< cir::FuncType, cir::FuncOp > getAddrAndTypeOfCXXStructor(clang::GlobalDecl gd, const CIRGenFunctionInfo *fnInfo=nullptr, cir::FuncType fnType=nullptr, bool dontDefer=false, ForDefinition_t isForDefinition=NotForDefinition)
void setGVProperties(mlir::Operation *op, const NamedDecl *d) const
Set visibility, dllimport/dllexport and dso_local.
cir::GlobalOp getOrCreateCIRGlobal(llvm::StringRef mangledName, mlir::Type ty, LangAS langAS, const VarDecl *d, ForDefinition_t isForDefinition)
If the specified mangled name is not in the module, create and return an mlir::GlobalOp value.
cir::FuncOp createCIRBuiltinFunction(mlir::Location loc, llvm::StringRef name, cir::FuncType ty, const clang::FunctionDecl *fd)
Create a CIR function with builtin attribute set.
clang::CharUnits getClassPointerAlignment(const clang::CXXRecordDecl *rd)
Return the best known alignment for an unknown pointer to a particular class.
void handleCXXStaticMemberVarInstantiation(VarDecl *vd)
Tell the consumer that this variable has been instantiated.
void emitGlobalDefinition(clang::GlobalDecl gd, mlir::Operation *op=nullptr)
mlir::Attribute getAddrOfRTTIDescriptor(mlir::Location loc, QualType ty, bool forEH=false)
Get the address of the RTTI descriptor for the given type.
clang::CharUnits getNaturalTypeAlignment(clang::QualType t, LValueBaseInfo *baseInfo)
FIXME: this could likely be a common helper and not necessarily related with codegen.
void setFunctionAttributes(GlobalDecl gd, cir::FuncOp f, bool isIncompleteFunction, bool isThunk)
Set function attributes for a function declaration.
static mlir::SymbolTable::Visibility getMLIRVisibilityFromCIRLinkage(cir::GlobalLinkageKind GLK)
const clang::TargetInfo & getTarget() const
const llvm::Triple & getTriple() const
static mlir::SymbolTable::Visibility getMLIRVisibility(Visibility v)
void emitTentativeDefinition(const VarDecl *d)
cir::GlobalOp createOrReplaceCXXRuntimeVariable(mlir::Location loc, llvm::StringRef name, mlir::Type ty, cir::GlobalLinkageKind linkage, clang::CharUnits alignment)
Will return a global variable of the given type.
void emitGlobalDecl(const clang::GlobalDecl &d)
Helper for emitDeferred to apply actual codegen.
cir::FuncOp getOrCreateCIRFunction(llvm::StringRef mangledName, mlir::Type funcType, clang::GlobalDecl gd, bool forVTable, bool dontDefer=false, bool isThunk=false, ForDefinition_t isForDefinition=NotForDefinition, mlir::ArrayAttr extraAttrs={})
void emitGlobalVarDefinition(const clang::VarDecl *vd, bool isTentative=false)
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.
void emitAliasForGlobal(llvm::StringRef mangledName, mlir::Operation *op, GlobalDecl aliasGD, cir::FuncOp aliasee, cir::GlobalLinkageKind linkage)
void emitGlobalOpenACCDecl(const clang::OpenACCConstructDecl *cd)
bool verifyModule() const
void emitExplicitCastExprType(const ExplicitCastExpr *e, CIRGenFunction *cgf=nullptr)
Emit type info if type of an expression is a variably modified type.
std::map< llvm::StringRef, clang::GlobalDecl > deferredDecls
This contains all the decls which have definitions but which are deferred for emission and therefore ...
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.
static void setInitializer(cir::GlobalOp &op, mlir::Attribute value)
cir::GlobalViewAttr getAddrOfGlobalVarAttr(const VarDecl *d)
Return the mlir::GlobalViewAttr for the address of the given global.
cir::GlobalLinkageKind getFunctionLinkage(GlobalDecl gd)
void updateCompletedType(const clang::TagDecl *td)
const clang::CodeGenOptions & getCodeGenOpts() const
const clang::LangOptions & getLangOpts() const
void addDeferredDeclToEmit(clang::GlobalDecl GD)
cir::FuncOp createCIRFunction(mlir::Location loc, llvm::StringRef name, cir::FuncType funcType, const clang::FunctionDecl *funcDecl)
const TargetCIRGenInfo & getTargetCIRGenInfo()
void emitCXXGlobalVarDeclInitFunc(const VarDecl *vd, cir::GlobalOp addr, bool performInit)
void setGVPropertiesAux(mlir::Operation *op, const NamedDecl *d) const
mlir::Location getLoc(clang::SourceLocation cLoc)
Helpers to convert the presumed location of Clang's SourceLocation to an MLIR Location.
llvm::DenseMap< mlir::Attribute, cir::GlobalOp > constantStringMap
mlir::Operation * lastGlobalOp
static cir::VisibilityKind getGlobalVisibilityKindFromClangVisibility(clang::VisibilityAttr::VisibilityType visibility)
llvm::StringMap< unsigned > cgGlobalNames
mlir::Operation * getGlobalValue(llvm::StringRef ref)
mlir::ModuleOp getModule() const
bool supportsCOMDAT() const
cir::GlobalLinkageKind getCIRLinkageForDeclarator(const DeclaratorDecl *dd, GVALinkage linkage, bool isConstantVariable)
mlir::MLIRContext & getMLIRContext()
mlir::Operation * getAddrOfGlobal(clang::GlobalDecl gd, ForDefinition_t isForDefinition=NotForDefinition)
static cir::GlobalOp createGlobalOp(CIRGenModule &cgm, mlir::Location loc, llvm::StringRef name, mlir::Type t, bool isConstant=false, mlir::Operation *insertPoint=nullptr)
void maybeSetTrivialComdat(const clang::Decl &d, mlir::Operation *op)
CIRGenCXXABI & getCXXABI() const
cir::GlobalViewAttr getAddrOfConstantStringFromLiteral(const StringLiteral *s, llvm::StringRef name=".str")
Return a global symbol reference to a constant array for the given string literal.
void emitDeclContext(const DeclContext *dc)
void emitGlobal(clang::GlobalDecl gd)
Emit code for a single global function or variable declaration.
bool mayBeEmittedEagerly(const clang::ValueDecl *d)
Determine whether the definition can be emitted eagerly, or should be delayed until the end of the tr...
cir::GlobalLinkageKind getCIRLinkageVarDefinition(const VarDecl *vd, bool isConstant)
void emitGlobalFunctionDefinition(clang::GlobalDecl gd, mlir::Operation *op)
CIRGenVTables & getVTables()
void setFunctionLinkage(GlobalDecl gd, cir::FuncOp f)
std::vector< clang::GlobalDecl > deferredDeclsToEmit
mlir::Attribute getConstantArrayFromStringLiteral(const StringLiteral *e)
Return a constant array for the given string.
cir::VisibilityAttr getGlobalVisibilityAttrFromDecl(const Decl *decl)
void setCommonAttributes(GlobalDecl gd, mlir::Operation *op)
Set attributes which are common to any form of a global definition (alias, Objective-C method,...
const CIRGenFunctionInfo & arrangeGlobalDeclaration(GlobalDecl gd)
const CIRGenFunctionInfo & arrangeCXXMethodDeclaration(const clang::CXXMethodDecl *md)
C++ methods have some special rules and also have implicit parameters.
const CIRGenFunctionInfo & arrangeCXXStructorDeclaration(clang::GlobalDecl gd)
cir::FuncType getFunctionType(const CIRGenFunctionInfo &info)
Get the CIR function type for.
mlir::Type convertTypeForMem(clang::QualType, bool forBitField=false)
Convert type T into an mlir::Type.
void emitThunks(GlobalDecl gd)
Emit the associated thunks for the given global decl.
virtual cir::TargetAddressSpaceAttr getCIRAllocaAddressSpace() const
Get the address space for alloca.
Represents a base class of a C++ class.
Represents a C++ struct/union/class.
bool isEffectivelyFinal() const
Determine whether it's impossible for a class to be derived from this class.
bool hasDefinition() const
CharUnits - This is an opaque type for sizes expressed in character units.
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
static CharUnits One()
One - Construct a CharUnits quantity of one.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
static CharUnits Zero()
Zero - Construct a CharUnits quantity of zero.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
llvm::Reloc::Model RelocationModel
The name of the relocation model to use.
Represents the canonical version of C arrays with a specified constant size.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Decl - This represents one declaration (or definition), e.g.
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
static DeclContext * castToDeclContext(const Decl *)
const char * getDeclKindName() const
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Represents a ValueDecl that came out of a declarator.
SourceLocation getBeginLoc() const LLVM_READONLY
A little helper class used to produce diagnostics.
Concrete class used by the front-end to report problems and issues.
ExplicitCastExpr - An explicit cast written in the source code.
This represents one expression.
Represents a member of a struct/union/class.
Cached information about one file (either on disk or in the virtual file system).
StringRef tryGetRealPathName() const
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Represents a function declaration or definition.
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
FunctionType - C99 6.7.5.3 - Function Declarators.
CallingConv getCallConv() const
GlobalDecl - represents a global declaration.
GlobalDecl getCanonicalDecl() const
KernelReferenceKind getKernelReferenceKind() const
GlobalDecl getWithDecl(const Decl *D)
CXXDtorType getDtorType() const
const Decl * getDecl() const
One of these records is kept for each identifier that is lexed.
StringRef getName() const
Return the actual identifier string.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
void setLinkage(Linkage L)
Linkage getLinkage() const
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
bool shouldMangleDeclName(const NamedDecl *D)
void mangleName(GlobalDecl GD, raw_ostream &)
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
LinkageInfo getLinkageAndVisibility() const
Determines the linkage and visibility of this entity.
Represents an unpacked "presumed" location which can be presented to the user.
unsigned getColumn() const
Return the presumed column number of this location.
const char * getFilename() const
Return the presumed filename of this location.
unsigned getLine() const
Return the presumed line number of this location.
A (possibly-)qualified type.
LangAS getAddressSpace() const
Return the address space of this type.
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
bool isConstQualified() const
Determine whether this type is const-qualified.
bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
bool hasUnaligned() const
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
A trivial tuple used to represent a source range.
SourceLocation getEnd() const
SourceLocation getBegin() const
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.
StringRef getString() const
unsigned getCharByteWidth() const
Represents the declaration of a struct/union/class/enum.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
bool isPointerType() const
bool isReferenceType() const
bool isVariablyModifiedType() const
Whether this type is a variably-modified type (C99 6.7.5).
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isObjCObjectPointerType() const
const T * getAs() const
Member-template getAs<specific type>'.
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
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
bool hasFlexibleArrayInit(const ASTContext &Ctx) const
Whether this variable has a flexible array member initialized with one or more elements.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
bool hasConstantInitialization() const
Determine whether this variable has constant initialization.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
const Expr * getInit() const
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
@ Definition
This declaration is definitely a definition.
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
static LLVM_ATTRIBUTE_UNUSED bool isWeakForLinker(GlobalLinkageKind linkage)
Whether the definition of this global may be replaced at link time.
@ AttributedType
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
CIRGenCXXABI * CreateCIRGenItaniumCXXABI(CIRGenModule &cgm)
Creates and Itanium-family ABI.
std::unique_ptr< TargetCIRGenInfo > createX8664TargetCIRGenInfo(CIRGenTypes &cgt)
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
The JSON file list parser is used to communicate input to InstallAPI.
bool isa(CodeGen::Address addr)
GVALinkage
A more specific kind of linkage than enum Linkage.
@ GVA_AvailableExternally
@ SD_Thread
Thread storage duration.
@ SD_Static
Static storage duration.
@ Dtor_Complete
Complete object dtor.
LangAS
Defines the address space values used by the address space qualifier of QualType.
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
U cast(CodeGen::Address addr)
bool isExternallyVisible(Linkage L)
static bool alignCXXRecordDecl()
static bool weakRefReference()
static bool opGlobalSection()
static bool opGlobalConstant()
static bool addressSpace()
static bool opGlobalUnnamedAddr()
static bool opGlobalThreadLocal()
static bool sourceLanguageCases()
static bool cxxRecordStaticMembers()
static bool opFuncAstDeclAttr()
static bool opGlobalUsedOrCompilerUsed()
static bool moduleNameHash()
static bool opGlobalVisibility()
static bool setFunctionAttributes()
static bool setDLLStorageClass()
static bool opFuncParameterAttributes()
static bool targetCIRGenInfoArch()
static bool opFuncExtraAttrs()
static bool opFuncSection()
static bool opFuncAttributesForDefinition()
static bool opGlobalDLLImportExport()
static bool opGlobalPartition()
static bool opGlobalWeakRef()
static bool setTargetAttributes()
static bool deferredCXXGlobalInit()
static bool opFuncOperandBundles()
static bool defaultVisibility()
static bool opFuncExceptions()
static bool deferredVtables()
static bool cudaSupport()
static bool opFuncMaybeHandleStaticInExternC()
static bool generateDebugInfo()
static bool targetCIRGenInfoOS()
static bool opFuncCPUAndFeaturesAttributes()
static bool maybeHandleStaticInExternC()
static bool setLLVMFunctionFEnvAttributes()
cir::PointerType VoidPtrTy
void* in address space 0
cir::TargetAddressSpaceAttr cirAllocaAddressSpace
unsigned char PointerAlignInBytes
unsigned char SizeAlignInBytes
The alignment of size_t.
cir::PointerType UInt8PtrTy
mlir::Type UCharTy
ClangIR char.
LangStandard - Information about the properties of a particular language standard.