llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clangir @llvm/pr-subscribers-clang Author: David Rivera (RiverDave) <details> <summary>Changes</summary> Extends cir.global to accept address space attributes. Globals can now specify either `target_address_space(N)` or `lang_address_space(offload_*)`. Address spaces are also preserved throughout get_global ops. --- Patch is 28.27 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/179082.diff 14 Files Affected: - (modified) clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h (+8-6) - (modified) clang/include/clang/CIR/Dialect/IR/CIROps.td (+3) - (modified) clang/lib/CIR/CodeGen/CIRGenBuilder.h (+5-2) - (modified) clang/lib/CIR/CodeGen/CIRGenExpr.cpp (+2-2) - (modified) clang/lib/CIR/CodeGen/CIRGenModule.cpp (+51-12) - (modified) clang/lib/CIR/CodeGen/CIRGenModule.h (+16-4) - (modified) clang/lib/CIR/CodeGen/TargetInfo.cpp (+9) - (modified) clang/lib/CIR/CodeGen/TargetInfo.h (+7) - (modified) clang/lib/CIR/Dialect/IR/CIRDialect.cpp (+21-2) - (modified) clang/lib/CIR/Dialect/IR/CIRTypes.cpp (+15) - (modified) clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp (+19-20) - (modified) clang/test/CIR/IR/address-space.cir (+30) - (modified) clang/test/CIR/IR/invalid-addrspace.cir (+20) - (added) clang/test/CIR/Lowering/global-address-space.cir (+46) ``````````diff diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h index 345507d3402e9..5bfc9e38de0a4 100644 --- a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h +++ b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h @@ -18,6 +18,7 @@ #include "llvm/ADT/STLForwardCompat.h" #include "llvm/Support/ErrorHandling.h" +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "mlir/IR/Builders.h" #include "mlir/IR/BuiltinAttributes.h" #include "mlir/IR/Location.h" @@ -358,14 +359,15 @@ class CIRBaseBuilderTy : public mlir::OpBuilder { return CIRBaseBuilderTy::createStore(loc, flag, dst); } - [[nodiscard]] cir::GlobalOp createGlobal(mlir::ModuleOp mlirModule, - mlir::Location loc, - mlir::StringRef name, - mlir::Type type, bool isConstant, - cir::GlobalLinkageKind linkage) { + [[nodiscard]] cir::GlobalOp + createGlobal(mlir::ModuleOp mlirModule, mlir::Location loc, + mlir::StringRef name, mlir::Type type, bool isConstant, + cir::GlobalLinkageKind linkage, + mlir::ptr::MemorySpaceAttrInterface addrSpace) { mlir::OpBuilder::InsertionGuard guard(*this); setInsertionPointToStart(mlirModule.getBody()); - return cir::GlobalOp::create(*this, loc, name, type, isConstant, linkage); + return cir::GlobalOp::create(*this, loc, name, type, isConstant, addrSpace, + linkage); } cir::GetMemberOp createGetMember(mlir::Location loc, mlir::Type resultTy, diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td index fe35ab305f4ba..279bbd6513bdc 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIROps.td +++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td @@ -2219,6 +2219,7 @@ def CIR_GlobalOp : CIR_Op<"global", [ OptionalAttr<StrAttr>:$sym_visibility, TypeAttr:$sym_type, CIR_GlobalLinkageKind:$linkage, + OptionalAttr<MemorySpaceAttrInterface>:$addr_space, OptionalAttr<CIR_TLSModel>:$tls_model, OptionalAttr<AnyAttr>:$initial_value, UnitAttr:$comdat, @@ -2237,6 +2238,7 @@ def CIR_GlobalOp : CIR_Op<"global", [ (`comdat` $comdat^)? ($tls_model^)? (`dso_local` $dso_local^)? + (` ` custom<GlobalAddressSpaceValue>($addr_space)^ )? $sym_name custom<GlobalOpTypeAndInitialValue>($sym_type, $initial_value, $ctorRegion, $dtorRegion) @@ -2257,6 +2259,7 @@ def CIR_GlobalOp : CIR_Op<"global", [ "llvm::StringRef":$sym_name, "mlir::Type":$sym_type, CArg<"bool", "false">:$isConstant, + CArg<"mlir::ptr::MemorySpaceAttrInterface", "{}">:$addrSpace, // CIR defaults to external linkage. CArg<"cir::GlobalLinkageKind", "cir::GlobalLinkageKind::ExternalLinkage">:$linkage, diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.h b/clang/lib/CIR/CodeGen/CIRGenBuilder.h index dc1ce9a901381..785276a63221b 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuilder.h +++ b/clang/lib/CIR/CodeGen/CIRGenBuilder.h @@ -12,6 +12,7 @@ #include "Address.h" #include "CIRGenRecordLayout.h" #include "CIRGenTypeCache.h" +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "mlir/IR/Attributes.h" #include "mlir/IR/BuiltinAttributes.h" #include "mlir/Support/LLVM.h" @@ -595,7 +596,8 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy { [[nodiscard]] cir::GlobalOp createVersionedGlobal(mlir::ModuleOp module, mlir::Location loc, mlir::StringRef name, mlir::Type type, bool isConstant, - cir::GlobalLinkageKind linkage) { + cir::GlobalLinkageKind linkage, + mlir::ptr::MemorySpaceAttrInterface addrSpace = {}) { // Create a unique name if the given name is already taken. std::string uniqueName; if (unsigned version = globalsVersioning[name.str()]++) @@ -603,7 +605,8 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy { else uniqueName = name.str(); - return createGlobal(module, loc, uniqueName, type, isConstant, linkage); + return createGlobal(module, loc, uniqueName, type, isConstant, linkage, + addrSpace); } cir::StackSaveOp createStackSave(mlir::Location loc, mlir::Type ty) { diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp index ce0e62164029a..ab41b20d1689d 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp @@ -296,9 +296,9 @@ static LValue emitGlobalVarDeclLValue(CIRGenFunction &cgf, const Expr *e, // as part of getAddrOfGlobalVar. mlir::Value v = cgf.cgm.getAddrOfGlobalVar(vd); - assert(!cir::MissingFeatures::addressSpace()); mlir::Type realVarTy = cgf.convertTypeForMem(vd->getType()); - cir::PointerType realPtrTy = cgf.getBuilder().getPointerTo(realVarTy); + cir::PointerType realPtrTy = cir::PointerType::get( + realVarTy, mlir::cast<cir::PointerType>(v.getType()).getAddrSpace()); if (realPtrTy != v.getType()) v = cgf.getBuilder().createBitcast(v.getLoc(), v, realPtrTy); diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp index 61d84f197e6ec..c5b4cfc39b6c1 100644 --- a/clang/lib/CIR/CodeGen/CIRGenModule.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenModule.cpp @@ -23,11 +23,13 @@ #include "clang/Basic/SourceManager.h" #include "clang/CIR/Dialect/IR/CIRAttrs.h" #include "clang/CIR/Dialect/IR/CIRDialect.h" +#include "clang/CIR/Dialect/IR/CIROpsEnums.h" #include "clang/CIR/Dialect/IR/CIRTypes.h" #include "clang/CIR/Interfaces/CIROpInterfaces.h" #include "clang/CIR/MissingFeatures.h" #include "CIRGenFunctionInfo.h" +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "mlir/IR/BuiltinOps.h" #include "mlir/IR/Location.h" #include "mlir/IR/MLIRContext.h" @@ -522,10 +524,11 @@ mlir::Operation *CIRGenModule::getGlobalValue(StringRef name) { return mlir::SymbolTable::lookupSymbolIn(theModule, name); } -cir::GlobalOp CIRGenModule::createGlobalOp(CIRGenModule &cgm, - mlir::Location loc, StringRef name, - mlir::Type t, bool isConstant, - mlir::Operation *insertPoint) { +cir::GlobalOp +CIRGenModule::createGlobalOp(CIRGenModule &cgm, mlir::Location loc, + StringRef name, mlir::Type t, bool isConstant, + mlir::ptr::MemorySpaceAttrInterface addrSpace, + mlir::Operation *insertPoint) { cir::GlobalOp g; CIRGenBuilderTy &builder = cgm.getBuilder(); @@ -545,7 +548,7 @@ cir::GlobalOp CIRGenModule::createGlobalOp(CIRGenModule &cgm, builder.setInsertionPointToStart(cgm.getModule().getBody()); } - g = cir::GlobalOp::create(builder, loc, name, t, isConstant); + g = cir::GlobalOp::create(builder, loc, name, t, isConstant, addrSpace); if (!insertPoint) cgm.lastGlobalOp = g; @@ -594,6 +597,39 @@ std::optional<cir::SourceLanguage> CIRGenModule::getCIRSourceLanguage() const { return std::nullopt; } +LangAS CIRGenModule::getGlobalVarAddressSpace(const VarDecl *d) { + if (langOpts.OpenCL) { + LangAS as = d ? d->getType().getAddressSpace() : LangAS::opencl_global; + assert(as == LangAS::opencl_global || as == LangAS::opencl_global_device || + as == LangAS::opencl_global_host || as == LangAS::opencl_constant || + as == LangAS::opencl_local || as >= LangAS::FirstTargetAddressSpace); + return as; + } + + if (langOpts.SYCLIsDevice && + (!d || d->getType().getAddressSpace() == LangAS::Default)) + llvm_unreachable("NYI"); + + if (langOpts.CUDA && langOpts.CUDAIsDevice) { + if (d) { + if (d->hasAttr<CUDAConstantAttr>()) + return LangAS::cuda_constant; + if (d->hasAttr<CUDASharedAttr>()) + return LangAS::cuda_shared; + if (d->hasAttr<CUDADeviceAttr>()) + return LangAS::cuda_device; + if (d->getType().isConstQualified()) + return LangAS::cuda_constant; + } + return LangAS::cuda_device; + } + + if (langOpts.OpenMP) + llvm_unreachable("NYI"); + + return getTargetCIRGenInfo().getGlobalVarAddressSpace(*this, d); +} + static void setLinkageForGV(cir::GlobalOp &gv, const NamedDecl *nd) { // Set linkage and visibility in case we never see a definition. LinkageInfo lv = nd->getLinkageAndVisibility(); @@ -632,7 +668,6 @@ CIRGenModule::getOrCreateCIRGlobal(StringRef mangledName, mlir::Type ty, } if (entry) { - assert(!cir::MissingFeatures::addressSpace()); assert(!cir::MissingFeatures::opGlobalWeakRef()); assert(!cir::MissingFeatures::setDLLStorageClass()); @@ -651,6 +686,7 @@ CIRGenModule::getOrCreateCIRGlobal(StringRef mangledName, mlir::Type ty, errorNYI(d->getSourceRange(), "global with conflicting type"); } + // FIXME: Validate this // Address space check removed because it is unnecessary because CIR records // address space info in types. @@ -660,6 +696,9 @@ CIRGenModule::getOrCreateCIRGlobal(StringRef mangledName, mlir::Type ty, return entry; } + mlir::ptr::MemorySpaceAttrInterface declCIRAS = cir::toCIRAddressSpaceAttr( + &getMLIRContext(), getGlobalVarAddressSpace(d)); + mlir::Location loc = getLoc(d->getSourceRange()); // Calculate constant storage flag before creating the global. This was moved @@ -675,9 +714,9 @@ CIRGenModule::getOrCreateCIRGlobal(StringRef mangledName, mlir::Type ty, // mlir::SymbolTable::Visibility::Public is the default, no need to explicitly // mark it as such. - cir::GlobalOp gv = - CIRGenModule::createGlobalOp(*this, loc, mangledName, ty, isConstant, - /*insertPoint=*/entry.getOperation()); + cir::GlobalOp gv = CIRGenModule::createGlobalOp( + *this, loc, mangledName, ty, isConstant, declCIRAS, + /*insertPoint=*/entry.getOperation()); // This is the first use or definition of a mangled name. If there is a // deferred decl with this name, remember that we need to emit it at the end @@ -760,7 +799,7 @@ mlir::Value CIRGenModule::getAddrOfGlobalVar(const VarDecl *d, mlir::Type ty, bool tlsAccess = d->getTLSKind() != VarDecl::TLS_None; cir::GlobalOp g = getOrCreateCIRGlobal(d, ty, isForDefinition); - mlir::Type ptrTy = builder.getPointerTo(g.getSymType()); + mlir::Type ptrTy = builder.getPointerTo(g.getSymType(), g.getAddrSpaceAttr()); return cir::GetGlobalOp::create(builder, getLoc(d->getSourceRange()), ptrTy, g.getSymNameAttr(), tlsAccess); } @@ -770,8 +809,8 @@ cir::GlobalViewAttr CIRGenModule::getAddrOfGlobalVarAttr(const VarDecl *d) { mlir::Type ty = getTypes().convertTypeForMem(d->getType()); cir::GlobalOp globalOp = getOrCreateCIRGlobal(d, ty, NotForDefinition); - assert(!cir::MissingFeatures::addressSpace()); - cir::PointerType ptrTy = builder.getPointerTo(globalOp.getSymType()); + cir::PointerType ptrTy = + builder.getPointerTo(globalOp.getSymType(), globalOp.getAddrSpaceAttr()); return builder.getGlobalViewAttr(ptrTy, globalOp); } diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.h b/clang/lib/CIR/CodeGen/CIRGenModule.h index 3c4f35bacc4f9..10bc8ddd1809c 100644 --- a/clang/lib/CIR/CodeGen/CIRGenModule.h +++ b/clang/lib/CIR/CodeGen/CIRGenModule.h @@ -25,6 +25,7 @@ #include "clang/CIR/Dialect/IR/CIRDialect.h" #include "TargetInfo.h" +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "mlir/IR/Builders.h" #include "mlir/IR/BuiltinOps.h" #include "mlir/IR/MLIRContext.h" @@ -170,10 +171,11 @@ class CIRGenModule : public CIRGenTypeCache { cir::GlobalOp getOrCreateCIRGlobal(const VarDecl *d, mlir::Type ty, ForDefinition_t isForDefinition); - static cir::GlobalOp createGlobalOp(CIRGenModule &cgm, mlir::Location loc, - llvm::StringRef name, mlir::Type t, - bool isConstant = false, - mlir::Operation *insertPoint = nullptr); + static cir::GlobalOp + createGlobalOp(CIRGenModule &cgm, mlir::Location loc, llvm::StringRef name, + mlir::Type t, bool isConstant = false, + mlir::ptr::MemorySpaceAttrInterface addrSpace = {}, + mlir::Operation *insertPoint = nullptr); /// Add a global constructor or destructor to the module. /// The priority is optional, if not specified, the default priority is used. @@ -697,6 +699,16 @@ class CIRGenModule : public CIRGenTypeCache { /// Map source language used to a CIR attribute. std::optional<cir::SourceLanguage> getCIRSourceLanguage() const; + + /// Return the AST address space of the underlying global variable for D, as + /// determined by its declaration. Normally this is the same as the address + /// space of D's type, but in CUDA, address spaces are associated with + /// declarations, not types. If D is nullptr, return the default address + /// space for global variable. + /// + /// For languages without explicit address spaces, if D has default address + /// space, target-specific global or constant address space may be returned. + LangAS getGlobalVarAddressSpace(const VarDecl *decl); }; } // namespace CIRGen diff --git a/clang/lib/CIR/CodeGen/TargetInfo.cpp b/clang/lib/CIR/CodeGen/TargetInfo.cpp index b009478695f1b..50b973591d925 100644 --- a/clang/lib/CIR/CodeGen/TargetInfo.cpp +++ b/clang/lib/CIR/CodeGen/TargetInfo.cpp @@ -73,6 +73,15 @@ bool TargetCIRGenInfo::isNoProtoCallVariadic( return false; } +clang::LangAS +TargetCIRGenInfo::getGlobalVarAddressSpace(CIRGenModule &CGM, + const clang::VarDecl *D) const { + assert(!CGM.getLangOpts().OpenCL && + !(CGM.getLangOpts().CUDA && CGM.getLangOpts().CUDAIsDevice) && + "Address space agnostic languages only"); + return D ? D->getType().getAddressSpace() : LangAS::Default; +} + mlir::Value TargetCIRGenInfo::performAddrSpaceCast( CIRGenFunction &cgf, mlir::Value v, mlir::ptr::MemorySpaceAttrInterface srcAS, mlir::Type destTy, diff --git a/clang/lib/CIR/CodeGen/TargetInfo.h b/clang/lib/CIR/CodeGen/TargetInfo.h index 25bde654810ad..6108fa456b2c7 100644 --- a/clang/lib/CIR/CodeGen/TargetInfo.h +++ b/clang/lib/CIR/CodeGen/TargetInfo.h @@ -48,6 +48,13 @@ class TargetCIRGenInfo { /// Returns ABI info helper for the target. const ABIInfo &getABIInfo() const { return *info; } + /// Get target favored AST address space of a global variable for languages + /// other than OpenCL and CUDA. + /// If \p D is nullptr, returns the default target favored address space + /// for global variable. + virtual clang::LangAS getGlobalVarAddressSpace(CIRGenModule &CGM, + const clang::VarDecl *D) const; + /// Get the address space for alloca. virtual mlir::ptr::MemorySpaceAttrInterface getCIRAllocaAddressSpace() const { return {}; diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp index 7b9fc83403f71..024adecf866a6 100644 --- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp @@ -278,6 +278,13 @@ static void printOmittedTerminatorRegion(mlir::OpAsmPrinter &printer, /*printBlockTerminators=*/!omitRegionTerm(region)); } +mlir::OptionalParseResult +parseGlobalAddressSpaceValue(mlir::AsmParser &p, + mlir::ptr::MemorySpaceAttrInterface &attr); + +void printGlobalAddressSpaceValue(mlir::AsmPrinter &printer, cir::GlobalOp op, + mlir::ptr::MemorySpaceAttrInterface attr); + //===----------------------------------------------------------------------===// // AllocaOp //===----------------------------------------------------------------------===// @@ -1610,7 +1617,9 @@ mlir::LogicalResult cir::GlobalOp::verify() { void cir::GlobalOp::build( OpBuilder &odsBuilder, OperationState &odsState, llvm::StringRef sym_name, - mlir::Type sym_type, bool isConstant, cir::GlobalLinkageKind linkage, + mlir::Type sym_type, bool isConstant, + mlir::ptr::MemorySpaceAttrInterface addrSpace, + cir::GlobalLinkageKind linkage, function_ref<void(OpBuilder &, Location)> ctorBuilder, function_ref<void(OpBuilder &, Location)> dtorBuilder) { odsState.addAttribute(getSymNameAttrName(odsState.name), @@ -1620,6 +1629,8 @@ void cir::GlobalOp::build( if (isConstant) odsState.addAttribute(getConstantAttrName(odsState.name), odsBuilder.getUnitAttr()); + if (addrSpace) + odsState.addAttribute(getAddrSpaceAttrName(odsState.name), addrSpace); cir::GlobalLinkageKindAttr linkageAttr = cir::GlobalLinkageKindAttr::get(odsBuilder.getContext(), linkage); @@ -1773,9 +1784,10 @@ cir::GetGlobalOp::verifySymbolUses(SymbolTableCollection &symbolTable) { << "' does not reference a valid cir.global or cir.func"; mlir::Type symTy; + mlir::ptr::MemorySpaceAttrInterface symAddrSpaceAttr{}; if (auto g = dyn_cast<GlobalOp>(op)) { symTy = g.getSymType(); - assert(!cir::MissingFeatures::addressSpace()); + symAddrSpaceAttr = g.getAddrSpaceAttr(); // Verify that for thread local global access, the global needs to // be marked with tls bits. if (getTls() && !g.getTlsModel()) @@ -1792,6 +1804,13 @@ cir::GetGlobalOp::verifySymbolUses(SymbolTableCollection &symbolTable) { << resultType.getPointee() << "' does not match type " << symTy << " of the global @" << getName(); + if (symAddrSpaceAttr != resultType.getAddrSpace()) { + return emitOpError() + << "result type address space does not match the address " + "space of the global @" + << getName(); + } + return success(); } diff --git a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp index 42445a07864d8..a8f6ee6a0fda0 100644 --- a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp @@ -1057,6 +1057,21 @@ void printAddressSpaceValue(mlir::AsmPrinter &p, llvm_unreachable("unexpected address-space attribute kind"); } +mlir::OptionalParseResult +parseGlobalAddressSpaceValue(mlir::AsmParser &p, + mlir::ptr::MemorySpaceAttrInterface &attr) { + + mlir::SMLoc loc = p.getCurrentLocation(); + if (parseAddressSpaceValue(p, attr).failed()) + return p.emitError(loc, "failed to parse Address Space Value for GlobalOp"); + return mlir::success(); +} + +void printGlobalAddressSpaceValue(mlir::AsmPrinter &printer, cir::GlobalOp, + mlir::ptr::MemorySpaceAttrInterface attr) { + printAddressSpaceValue(printer, attr); +} + mlir::ptr::MemorySpaceAttrInterface cir::toCIRAddressSpaceAttr(mlir::MLIRContext *ctx, clang::LangAS langAS) { using clang::LangAS; diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index 584d163e15073..c5d6e06b219ce 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -102,6 +102,21 @@ static mlir::Value createIntCast(mlir::OpBuilder &bld, mlir::Value src, return mlir::LLVM::BitcastOp::create(bld, loc, dstTy, src); } +static unsigned +getNumericASFromCIRAS(mlir::ptr::MemorySpaceAttrInterface asAttr, + [[maybe_unused]] cir::LowerModule *lowerModule) { + if (!asAttr) + return 0; // default AS + if (auto targetAddrSpaceAttr = + mlir::dyn_cast_if_present<cir::TargetAddressSpaceAttr>(asAttr)) + return targetAddrSpaceAttr.getValue(); + + if (mlir::isa_and_present<cir::LangAddressSpaceAttr>(asAttr)) + llvm_unreachable("lowering LangAddressSpaceAttr NYI"); + + llvm_unreachable("unexpected address Space attribute kindI"); +} + static mlir::LLVM::Visibility lowerCIRVisibi... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/179082 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
