https://github.com/RiverDave updated https://github.com/llvm/llvm-project/pull/179073
>From e71fcdfb4f7ba18cbb98246193530937d7202b7c Mon Sep 17 00:00:00 2001 From: David Rivera <[email protected]> Date: Sat, 31 Jan 2026 17:48:05 -0500 Subject: [PATCH 1/9] [CIR] Infrastructure and MemorySpaceAttrInterface for Address Spaces --- .../CIR/Dialect/Builder/CIRBaseBuilder.h | 20 +- clang/include/clang/CIR/Dialect/IR/CIRAttrs.h | 1 + .../include/clang/CIR/Dialect/IR/CIRAttrs.td | 55 +++++- .../clang/CIR/Dialect/IR/CIREnumAttr.td | 19 ++ clang/include/clang/CIR/Dialect/IR/CIRTypes.h | 17 +- .../include/clang/CIR/Dialect/IR/CIRTypes.td | 10 +- clang/lib/CIR/CodeGen/Address.h | 3 +- clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp | 2 +- clang/lib/CIR/CodeGen/CIRGenExpr.cpp | 5 +- clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp | 1 + clang/lib/CIR/CodeGen/CIRGenTypeCache.h | 5 +- clang/lib/CIR/CodeGen/TargetInfo.cpp | 1 + clang/lib/CIR/CodeGen/TargetInfo.h | 3 +- clang/lib/CIR/Dialect/IR/CIRAttrs.cpp | 108 +++++++++- clang/lib/CIR/Dialect/IR/CIRTypes.cpp | 187 ++++++++++++++---- .../CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp | 17 +- clang/test/CIR/IR/address-space.cir | 41 ++++ clang/test/CIR/IR/invalid-addrspace.cir | 32 ++- 18 files changed, 451 insertions(+), 76 deletions(-) create mode 100644 clang/test/CIR/IR/address-space.cir diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h index efae3d9d894ed..f62dedb1f3f00 100644 --- a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h +++ b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h @@ -155,29 +155,27 @@ class CIRBaseBuilderTy : public mlir::OpBuilder { return cir::PointerType::get(ty); } - cir::PointerType getPointerTo(mlir::Type ty, cir::TargetAddressSpaceAttr as) { + cir::PointerType getPointerTo(mlir::Type ty, + mlir::ptr::MemorySpaceAttrInterface as) { + if (!as) + return cir::PointerType::get(ty); return cir::PointerType::get(ty, as); } cir::PointerType getPointerTo(mlir::Type ty, clang::LangAS langAS) { - if (langAS == clang::LangAS::Default) // Default address space. + if (langAS == clang::LangAS::Default) return getPointerTo(ty); - if (clang::isTargetAddressSpace(langAS)) { - unsigned addrSpace = clang::toTargetAddressSpace(langAS); - auto asAttr = cir::TargetAddressSpaceAttr::get( - getContext(), getUI32IntegerAttr(addrSpace)); - return getPointerTo(ty, asAttr); - } - - llvm_unreachable("language-specific address spaces NYI"); + mlir::ptr::MemorySpaceAttrInterface addrSpaceAttr = + cir::toCIRAddressSpaceAttr(getContext(), langAS); + return getPointerTo(ty, addrSpaceAttr); } cir::PointerType getVoidPtrTy(clang::LangAS langAS = clang::LangAS::Default) { return getPointerTo(cir::VoidType::get(getContext()), langAS); } - cir::PointerType getVoidPtrTy(cir::TargetAddressSpaceAttr as) { + cir::PointerType getVoidPtrTy(mlir::ptr::MemorySpaceAttrInterface as) { return getPointerTo(cir::VoidType::get(getContext()), as); } diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.h b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.h index eb87dc083b0f5..f6674a10af66b 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.h +++ b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.h @@ -13,6 +13,7 @@ #ifndef CLANG_CIR_DIALECT_IR_CIRATTRS_H #define CLANG_CIR_DIALECT_IR_CIRATTRS_H +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "mlir/IR/Attributes.h" #include "mlir/IR/BuiltinAttributeInterfaces.h" #include "clang/Basic/AddressSpaces.h" diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td index 845ec4a85fa7d..b1be1d5daf4e0 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td +++ b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td @@ -14,6 +14,7 @@ #define CLANG_CIR_DIALECT_IR_CIRATTRS_TD include "mlir/IR/BuiltinAttributeInterfaces.td" +include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.td" include "clang/CIR/Dialect/IR/CIRAttrConstraints.td" include "clang/CIR/Dialect/IR/CIRDialect.td" @@ -783,16 +784,64 @@ def CIR_DynamicCastInfoAttr : CIR_Attr<"DynamicCastInfo", "dyn_cast_info"> { }]; } +//===----------------------------------------------------------------------===// +// LangAddressSpaceAttr +//===----------------------------------------------------------------------===// + +def CIR_LangAddressSpaceAttr : CIR_EnumAttr<CIR_LangAddressSpace, + "lang_address_space", [ + DeclareAttrInterfaceMethods<MemorySpaceAttrInterface> +]> { + let summary = "Represents a language address space"; + let description = [{ + Encodes the semantic address spaces defined by the front-end language + (e.g. `__shared__`, `__constant__`, `__local__`). Values are stored using the + `cir::LangAddressSpace` enum, keeping the representation compact and + preserving the qualifier until it is mapped onto target/LLVM address-space + numbers. + + Example: + ```mlir + !cir.ptr<!s32i, lang_address_space(offload_local)> + cir.global constant external lang_address_space(offload_constant) + ``` + }]; + + let builders = [ + AttrBuilder<(ins "clang::LangAS":$langAS), [{ + return $_get($_ctxt, cir::toCIRLangAddressSpace(langAS)); + }]> + ]; + + let assemblyFormat = [{ + `(` custom<AddressSpaceValue>($value) `)` + }]; + + let defaultValue = "cir::LangAddressSpace::Default"; + + let extraClassDeclaration = [{ + unsigned getAsUnsignedValue() const; + }]; + + let extraClassDefinition = [{ + unsigned $cppClass::getAsUnsignedValue() const { + return static_cast<unsigned>(getValue()); + } + }]; +} + //===----------------------------------------------------------------------===// // TargetAddressSpaceAttr //===----------------------------------------------------------------------===// def CIR_TargetAddressSpaceAttr : CIR_Attr< "TargetAddressSpace", - "target_address_space"> { + "target_address_space", [ + DeclareAttrInterfaceMethods<MemorySpaceAttrInterface> + ]> { let summary = "Represents a target-specific numeric address space"; let description = [{ The TargetAddressSpaceAttr represents a target-specific numeric address space, - corresponding to the LLVM IR `addressspace` qualifier and the clang + corresponding to the LLVM IR `addrspace` qualifier and the clang `address_space` attribute. A value of zero represents the default address space. The semantics of non-zero @@ -806,7 +855,7 @@ def CIR_TargetAddressSpaceAttr : CIR_Attr< "TargetAddressSpace", ``` }]; - let parameters = (ins "mlir::IntegerAttr":$value); + let parameters = (ins "unsigned":$value); let assemblyFormat = "`<` `target` `<` $value `>` `>`"; } diff --git a/clang/include/clang/CIR/Dialect/IR/CIREnumAttr.td b/clang/include/clang/CIR/Dialect/IR/CIREnumAttr.td index 98b8a31d2a18a..1de6ffdc08d72 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIREnumAttr.td +++ b/clang/include/clang/CIR/Dialect/IR/CIREnumAttr.td @@ -14,6 +14,7 @@ #define CLANG_CIR_DIALECT_IR_CIRENUMATTR_TD include "mlir/IR/EnumAttr.td" +include "clang/CIR/Dialect/IR/CIRDialect.td" class CIR_I32EnumAttr<string name, string summary, list<I32EnumAttrCase> cases> : I32EnumAttr<name, summary, cases> { @@ -35,4 +36,22 @@ class CIR_DefaultValuedEnumParameter<EnumAttrInfo info, string value = ""> let defaultValue = value; } +def CIR_LangAddressSpace : CIR_I32EnumAttr< + "LangAddressSpace", "language address space kind", [ + I32EnumAttrCase<"Default", 0, "default">, + I32EnumAttrCase<"OffloadPrivate", 1, "offload_private">, + I32EnumAttrCase<"OffloadLocal", 2, "offload_local">, + I32EnumAttrCase<"OffloadGlobal", 3, "offload_global">, + I32EnumAttrCase<"OffloadConstant", 4, "offload_constant">, + I32EnumAttrCase<"OffloadGeneric", 5, "offload_generic"> +]> { + let description = [{ + Enumerates language-specific address spaces used by CIR. These represent + semantic qualifiers from source languages (e.g., CUDA `__shared__`, + OpenCL `__local`) before target lowering. + }]; + + let genSpecializedAttr = 0; +} + #endif // CLANG_CIR_DIALECT_IR_CIRENUMATTR_TD diff --git a/clang/include/clang/CIR/Dialect/IR/CIRTypes.h b/clang/include/clang/CIR/Dialect/IR/CIRTypes.h index 939e774a6ea67..eee4140ba2801 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRTypes.h +++ b/clang/include/clang/CIR/Dialect/IR/CIRTypes.h @@ -13,6 +13,7 @@ #ifndef CLANG_CIR_DIALECT_IR_CIRTYPES_H #define CLANG_CIR_DIALECT_IR_CIRTYPES_H +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "mlir/IR/Attributes.h" #include "mlir/IR/BuiltinAttributes.h" #include "mlir/IR/MLIRContext.h" @@ -43,12 +44,22 @@ bool isSized(mlir::Type ty); //===----------------------------------------------------------------------===// // AddressSpace helpers //===----------------------------------------------------------------------===// -cir::TargetAddressSpaceAttr toCIRTargetAddressSpace(mlir::MLIRContext &context, - clang::LangAS langAS); -bool isMatchingAddressSpace(cir::TargetAddressSpaceAttr cirAS, +cir::LangAddressSpace toCIRLangAddressSpace(clang::LangAS langAS); + +// Compare a CIR memory space attribute with a Clang LangAS. +bool isMatchingAddressSpace(mlir::MLIRContext &ctx, + mlir::ptr::MemorySpaceAttrInterface cirAS, clang::LangAS as); +/// Convert an AST LangAS to the appropriate CIR address space attribute +/// interface. +mlir::ptr::MemorySpaceAttrInterface +toCIRAddressSpaceAttr(mlir::MLIRContext *ctx, clang::LangAS langAS); + +bool isSupportedCIRMemorySpaceAttr( + mlir::ptr::MemorySpaceAttrInterface memorySpace); + } // namespace cir //===----------------------------------------------------------------------===// diff --git a/clang/include/clang/CIR/Dialect/IR/CIRTypes.td b/clang/include/clang/CIR/Dialect/IR/CIRTypes.td index ea2113432d5b5..9b01ee54f8afe 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRTypes.td +++ b/clang/include/clang/CIR/Dialect/IR/CIRTypes.td @@ -252,19 +252,19 @@ def CIR_PointerType : CIR_Type<"Pointer", "ptr", [ let parameters = (ins "mlir::Type":$pointee, OptionalParameter< - "cir::TargetAddressSpaceAttr">:$addrSpace + "mlir::ptr::MemorySpaceAttrInterface">:$addrSpace ); let skipDefaultBuilders = 1; let builders = [ TypeBuilderWithInferredContext<(ins "mlir::Type":$pointee, - CArg<"cir::TargetAddressSpaceAttr", "nullptr">:$addrSpace), [{ + CArg<"mlir::ptr::MemorySpaceAttrInterface", "{}">:$addrSpace), [{ return $_get(pointee.getContext(), pointee, addrSpace); }]>, TypeBuilder<(ins "mlir::Type":$pointee, - CArg<"cir::TargetAddressSpaceAttr", "nullptr">:$addrSpace), [{ + CArg<"mlir::ptr::MemorySpaceAttrInterface", "{}">:$addrSpace), [{ return $_get($_ctxt, pointee, addrSpace); }]> ]; @@ -272,7 +272,7 @@ def CIR_PointerType : CIR_Type<"Pointer", "ptr", [ let assemblyFormat = [{ `<` $pointee - ( `,` ` ` custom<TargetAddressSpace>($addrSpace)^ )? + ( `,` ` ` custom<AddressSpaceValue>($addrSpace)^ )? `>` }]; @@ -303,6 +303,8 @@ def CIR_PointerType : CIR_Type<"Pointer", "ptr", [ return false; } }]; + + let genVerifyDecl = 1; } //===----------------------------------------------------------------------===// diff --git a/clang/lib/CIR/CodeGen/Address.h b/clang/lib/CIR/CodeGen/Address.h index f32cde957cd5c..b459ec948c2c4 100644 --- a/clang/lib/CIR/CodeGen/Address.h +++ b/clang/lib/CIR/CodeGen/Address.h @@ -14,6 +14,7 @@ #ifndef CLANG_LIB_CIR_ADDRESS_H #define CLANG_LIB_CIR_ADDRESS_H +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "mlir/IR/Value.h" #include "clang/AST/CharUnits.h" #include "clang/CIR/Dialect/IR/CIRAttrs.h" @@ -127,7 +128,7 @@ class Address { return elementType; } - cir::TargetAddressSpaceAttr getAddressSpace() const { + mlir::ptr::MemorySpaceAttrInterface getAddressSpace() const { auto ptrTy = mlir::dyn_cast<cir::PointerType>(getType()); return ptrTy.getAddrSpace(); } diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp index a27e66e0989fa..1fc72aa43144c 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp @@ -378,7 +378,7 @@ static RValue emitBuiltinAlloca(CIRGenFunction &cgf, const CallExpr *e, // builtin / dynamic alloca we have to handle it here. if (!cir::isMatchingAddressSpace( - cgf.getCIRAllocaAddressSpace(), + cgf.getMLIRContext(), cgf.getCIRAllocaAddressSpace(), e->getType()->getPointeeType().getAddressSpace())) { cgf.cgm.errorNYI(e->getSourceRange(), "Non-default address space for alloca"); diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp index f8ad143977ff1..20f656e4471e2 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp @@ -15,6 +15,7 @@ #include "CIRGenFunction.h" #include "CIRGenModule.h" #include "CIRGenValue.h" +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "mlir/IR/BuiltinAttributes.h" #include "mlir/IR/Value.h" #include "clang/AST/Attr.h" @@ -1455,9 +1456,9 @@ LValue CIRGenFunction::emitCastLValue(const CastExpr *e) { QualType destTy = getContext().getPointerType(e->getType()); clang::LangAS srcLangAS = e->getSubExpr()->getType().getAddressSpace(); - cir::TargetAddressSpaceAttr srcAS; + mlir::ptr::MemorySpaceAttrInterface srcAS; if (clang::isTargetAddressSpace(srcLangAS)) - srcAS = cir::toCIRTargetAddressSpace(getMLIRContext(), srcLangAS); + srcAS = cir::toCIRAddressSpaceAttr(&getMLIRContext(), srcLangAS); else cgm.errorNYI( e->getSourceRange(), diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp index 567c60844af1e..1c146d0ea9d17 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp @@ -19,6 +19,7 @@ #include "clang/CIR/Dialect/IR/CIRTypes.h" #include "clang/CIR/MissingFeatures.h" +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "mlir/IR/Location.h" #include "mlir/IR/Value.h" diff --git a/clang/lib/CIR/CodeGen/CIRGenTypeCache.h b/clang/lib/CIR/CodeGen/CIRGenTypeCache.h index 0f63e91f45564..4f3c319816e3a 100644 --- a/clang/lib/CIR/CodeGen/CIRGenTypeCache.h +++ b/clang/lib/CIR/CodeGen/CIRGenTypeCache.h @@ -13,6 +13,7 @@ #ifndef LLVM_CLANG_LIB_CIR_CIRGENTYPECACHE_H #define LLVM_CLANG_LIB_CIR_CIRGENTYPECACHE_H +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "clang/AST/CharUnits.h" #include "clang/Basic/AddressSpaces.h" #include "clang/CIR/Dialect/IR/CIRTypes.h" @@ -80,7 +81,7 @@ struct CIRGenTypeCache { unsigned char SizeAlignInBytes; }; - cir::TargetAddressSpaceAttr cirAllocaAddressSpace; + mlir::ptr::MemorySpaceAttrInterface cirAllocaAddressSpace; clang::CharUnits getSizeSize() const { return clang::CharUnits::fromQuantity(SizeSizeInBytes); @@ -93,7 +94,7 @@ struct CIRGenTypeCache { return clang::CharUnits::fromQuantity(PointerAlignInBytes); } - cir::TargetAddressSpaceAttr getCIRAllocaAddressSpace() const { + mlir::ptr::MemorySpaceAttrInterface getCIRAllocaAddressSpace() const { return cirAllocaAddressSpace; } }; diff --git a/clang/lib/CIR/CodeGen/TargetInfo.cpp b/clang/lib/CIR/CodeGen/TargetInfo.cpp index 5a0c854db9125..2f3824d3d47a7 100644 --- a/clang/lib/CIR/CodeGen/TargetInfo.cpp +++ b/clang/lib/CIR/CodeGen/TargetInfo.cpp @@ -1,6 +1,7 @@ #include "TargetInfo.h" #include "ABIInfo.h" #include "CIRGenFunction.h" +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "clang/CIR/Dialect/IR/CIRAttrs.h" #include "clang/CIR/Dialect/IR/CIRDialect.h" diff --git a/clang/lib/CIR/CodeGen/TargetInfo.h b/clang/lib/CIR/CodeGen/TargetInfo.h index 79325c2d35c4d..b60ba22af64ce 100644 --- a/clang/lib/CIR/CodeGen/TargetInfo.h +++ b/clang/lib/CIR/CodeGen/TargetInfo.h @@ -16,6 +16,7 @@ #include "ABIInfo.h" #include "CIRGenTypes.h" +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "clang/Basic/AddressSpaces.h" #include "clang/CIR/Dialect/IR/CIRAttrs.h" @@ -48,7 +49,7 @@ class TargetCIRGenInfo { const ABIInfo &getABIInfo() const { return *info; } /// Get the address space for alloca. - virtual cir::TargetAddressSpaceAttr getCIRAllocaAddressSpace() const { + virtual mlir::ptr::MemorySpaceAttrInterface getCIRAllocaAddressSpace() const { return {}; } diff --git a/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp b/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp index 43bd33759fba9..67509f3cf452a 100644 --- a/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp @@ -10,6 +10,7 @@ // //===----------------------------------------------------------------------===// +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "clang/CIR/Dialect/IR/CIRDialect.h" #include "mlir/IR/DialectImplementation.h" @@ -47,11 +48,21 @@ parseFloatLiteral(mlir::AsmParser &parser, // AddressSpaceAttr //===----------------------------------------------------------------------===// -mlir::ParseResult parseTargetAddressSpace(mlir::AsmParser &p, - cir::TargetAddressSpaceAttr &attr); +mlir::ParseResult parseAddressSpaceValue(mlir::AsmParser &p, + cir::LangAddressSpace &addrSpace) { + llvm::SMLoc loc = p.getCurrentLocation(); + mlir::FailureOr<cir::LangAddressSpace> result = + mlir::FieldParser<cir::LangAddressSpace>::parse(p); + if (mlir::failed(result)) + return p.emitError(loc, "expected address space keyword"); + addrSpace = result.value(); + return mlir::success(); +} -void printTargetAddressSpace(mlir::AsmPrinter &p, - cir::TargetAddressSpaceAttr attr); +void printAddressSpaceValue(mlir::AsmPrinter &p, + cir::LangAddressSpace addrSpace) { + p << cir::stringifyEnum(addrSpace); +} static mlir::ParseResult parseConstPtr(mlir::AsmParser &parser, mlir::IntegerAttr &value); @@ -64,6 +75,95 @@ static void printConstPtr(mlir::AsmPrinter &p, mlir::IntegerAttr value); using namespace mlir; using namespace cir; +//===----------------------------------------------------------------------===// +// MemorySpaceAttrInterface implementations for Lang and Target address space +// attributes +//===----------------------------------------------------------------------===// + +bool LangAddressSpaceAttr::isValidLoad( + mlir::Type type, mlir::ptr::AtomicOrdering ordering, + std::optional<int64_t> alignment, const mlir::DataLayout *dataLayout, + llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const { + llvm_unreachable("isValidLoad for LangAddressSpaceAttr NYI"); +} + +bool LangAddressSpaceAttr::isValidStore( + mlir::Type type, mlir::ptr::AtomicOrdering ordering, + std::optional<int64_t> alignment, const mlir::DataLayout *dataLayout, + llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const { + llvm_unreachable("isValidStore for LangAddressSpaceAttr NYI"); +} + +bool LangAddressSpaceAttr::isValidAtomicOp( + mlir::ptr::AtomicBinOp op, mlir::Type type, + mlir::ptr::AtomicOrdering ordering, std::optional<int64_t> alignment, + const mlir::DataLayout *dataLayout, + llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const { + llvm_unreachable("isValidAtomicOp for LangAddressSpaceAttr NYI"); +} + +bool LangAddressSpaceAttr::isValidAtomicXchg( + mlir::Type type, mlir::ptr::AtomicOrdering successOrdering, + mlir::ptr::AtomicOrdering failureOrdering, std::optional<int64_t> alignment, + const mlir::DataLayout *dataLayout, + llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const { + llvm_unreachable("isValidAtomicXchg for LangAddressSpaceAttr NYI"); +} + +bool LangAddressSpaceAttr::isValidAddrSpaceCast( + mlir::Type tgt, mlir::Type src, + llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const { + llvm_unreachable("isValidAddrSpaceCast for LangAddressSpaceAttr NYI"); +} + +bool LangAddressSpaceAttr::isValidPtrIntCast( + mlir::Type intLikeTy, mlir::Type ptrLikeTy, + llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const { + llvm_unreachable("isValidPtrIntCast for LangAddressSpaceAttr NYI"); +} + +bool TargetAddressSpaceAttr::isValidLoad( + mlir::Type type, mlir::ptr::AtomicOrdering ordering, + std::optional<int64_t> alignment, const mlir::DataLayout *dataLayout, + llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const { + llvm_unreachable("isValidLoad for TargetAddressSpaceAttr NYI"); +} + +bool TargetAddressSpaceAttr::isValidStore( + mlir::Type type, mlir::ptr::AtomicOrdering ordering, + std::optional<int64_t> alignment, const mlir::DataLayout *dataLayout, + llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const { + llvm_unreachable("isValidStore for TargetAddressSpaceAttr NYI"); +} + +bool TargetAddressSpaceAttr::isValidAtomicOp( + mlir::ptr::AtomicBinOp op, mlir::Type type, + mlir::ptr::AtomicOrdering ordering, std::optional<int64_t> alignment, + const mlir::DataLayout *dataLayout, + llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const { + llvm_unreachable("isValidAtomicOp for TargetAddressSpaceAttr NYI"); +} + +bool TargetAddressSpaceAttr::isValidAtomicXchg( + mlir::Type type, mlir::ptr::AtomicOrdering successOrdering, + mlir::ptr::AtomicOrdering failureOrdering, std::optional<int64_t> alignment, + const mlir::DataLayout *dataLayout, + llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const { + llvm_unreachable("isValidAtomicXchg for TargetAddressSpaceAttr NYI"); +} + +bool TargetAddressSpaceAttr::isValidAddrSpaceCast( + mlir::Type tgt, mlir::Type src, + llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const { + llvm_unreachable("isValidAddrSpaceCast for TargetAddressSpaceAttr NYI"); +} + +bool TargetAddressSpaceAttr::isValidPtrIntCast( + mlir::Type intLikeTy, mlir::Type ptrLikeTy, + llvm::function_ref<mlir::InFlightDiagnostic()> emitError) const { + llvm_unreachable("isValidPtrIntCast for TargetAddressSpaceAttr NYI"); +} + //===----------------------------------------------------------------------===// // General CIR parsing / printing //===----------------------------------------------------------------------===// diff --git a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp index 43853b6696a94..42445a07864d8 100644 --- a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp @@ -12,12 +12,15 @@ #include "clang/CIR/Dialect/IR/CIRTypes.h" +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "mlir/IR/BuiltinAttributes.h" #include "mlir/IR/DialectImplementation.h" #include "mlir/IR/MLIRContext.h" +#include "mlir/Support/LLVM.h" #include "clang/Basic/AddressSpaces.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/CIRTypesDetails.h" #include "clang/CIR/MissingFeatures.h" #include "llvm/ADT/APInt.h" @@ -60,6 +63,14 @@ static void printFuncTypeParams(mlir::AsmPrinter &p, // AddressSpace //===----------------------------------------------------------------------===// +mlir::ParseResult +parseAddressSpaceValue(mlir::AsmParser &p, + mlir::ptr::MemorySpaceAttrInterface &attr); + +void printAddressSpaceValue(mlir::AsmPrinter &printer, + mlir::ptr::MemorySpaceAttrInterface attr); + +// Custom parser/printer for the `addrSpace` parameter in `!cir.ptr`. mlir::ParseResult parseTargetAddressSpace(mlir::AsmParser &p, cir::TargetAddressSpaceAttr &attr); @@ -930,58 +941,158 @@ void cir::VectorType::print(mlir::AsmPrinter &odsPrinter) const { } //===----------------------------------------------------------------------===// -// TargetAddressSpace definitions +// AddressSpace definitions //===----------------------------------------------------------------------===// -cir::TargetAddressSpaceAttr -cir::toCIRTargetAddressSpace(mlir::MLIRContext &context, clang::LangAS langAS) { - return cir::TargetAddressSpaceAttr::get( - &context, - IntegerAttr::get(&context, - llvm::APSInt(clang::toTargetAddressSpace(langAS)))); +bool cir::isSupportedCIRMemorySpaceAttr( + mlir::ptr::MemorySpaceAttrInterface memorySpace) { + return mlir::isa<cir::LangAddressSpaceAttr, cir::TargetAddressSpaceAttr>( + memorySpace); +} + +cir::LangAddressSpace cir::toCIRLangAddressSpace(clang::LangAS langAS) { + using clang::LangAS; + switch (langAS) { + case LangAS::Default: + return LangAddressSpace::Default; + case LangAS::opencl_global: + return LangAddressSpace::OffloadGlobal; + case LangAS::opencl_local: + case LangAS::cuda_shared: + // Local means local among the work-group (OpenCL) or block (CUDA). + // All threads inside the kernel can access local memory. + return LangAddressSpace::OffloadLocal; + case LangAS::cuda_device: + return LangAddressSpace::OffloadGlobal; + case LangAS::opencl_constant: + case LangAS::cuda_constant: + return LangAddressSpace::OffloadConstant; + case LangAS::opencl_private: + return LangAddressSpace::OffloadPrivate; + case LangAS::opencl_generic: + return LangAddressSpace::OffloadGeneric; + case LangAS::opencl_global_device: + case LangAS::opencl_global_host: + case LangAS::sycl_global: + case LangAS::sycl_global_device: + case LangAS::sycl_global_host: + case LangAS::sycl_local: + case LangAS::sycl_private: + case LangAS::ptr32_sptr: + case LangAS::ptr32_uptr: + case LangAS::ptr64: + case LangAS::hlsl_groupshared: + case LangAS::wasm_funcref: + llvm_unreachable("NYI"); + default: + llvm_unreachable("unknown/unsupported clang language address space"); + } } -bool cir::isMatchingAddressSpace(cir::TargetAddressSpaceAttr cirAS, - clang::LangAS as) { - // If there is no CIR target attr, consider it "default" and only match - // when the AST address space is LangAS::Default. - if (!cirAS) - return as == clang::LangAS::Default; +mlir::ParseResult +parseAddressSpaceValue(mlir::AsmParser &p, + mlir::ptr::MemorySpaceAttrInterface &attr) { - if (!isTargetAddressSpace(as)) - return false; + llvm::SMLoc loc = p.getCurrentLocation(); - return cirAS.getValue().getUInt() == toTargetAddressSpace(as); -} + // Try to parse target address space first. + attr = nullptr; + if (p.parseOptionalKeyword("target_address_space").succeeded()) { + unsigned val; + if (p.parseLParen()) + return p.emitError(loc, "expected '(' after 'target_address_space'"); -mlir::ParseResult parseTargetAddressSpace(mlir::AsmParser &p, - cir::TargetAddressSpaceAttr &attr) { - if (failed(p.parseKeyword("target_address_space"))) - return mlir::failure(); + if (p.parseInteger(val)) + return p.emitError(loc, "expected target address space value"); + + if (p.parseRParen()) + return p.emitError(loc, "expected ')'"); - if (failed(p.parseLParen())) - return mlir::failure(); + attr = cir::TargetAddressSpaceAttr::get(p.getContext(), val); + return mlir::success(); + } - int32_t targetValue; - if (failed(p.parseInteger(targetValue))) - return p.emitError(p.getCurrentLocation(), - "expected integer address space value"); + // Try to parse language specific address space. + if (p.parseOptionalKeyword("lang_address_space").succeeded()) { + if (p.parseLParen()) + return p.emitError(loc, "expected '(' after 'lang_address_space'"); - if (failed(p.parseRParen())) - return p.emitError(p.getCurrentLocation(), - "expected ')' after address space value"); + mlir::FailureOr<cir::LangAddressSpace> result = + mlir::FieldParser<cir::LangAddressSpace>::parse(p); + if (mlir::failed(result)) + return mlir::failure(); + + if (p.parseRParen()) + return p.emitError(loc, "expected ')'"); + + attr = cir::LangAddressSpaceAttr::get(p.getContext(), result.value()); + return mlir::success(); + } + + llvm::StringRef keyword; + if (p.parseOptionalKeyword(&keyword).succeeded()) + return p.emitError(loc, "unknown address space specifier '") + << keyword << "'; expected 'target_address_space' or " + << "'lang_address_space'"; - mlir::MLIRContext *context = p.getBuilder().getContext(); - attr = cir::TargetAddressSpaceAttr::get( - context, p.getBuilder().getUI32IntegerAttr(targetValue)); return mlir::success(); } -// The custom printer for the `addrspace` parameter in `!cir.ptr`. -// in the format of `target_address_space(N)`. -void printTargetAddressSpace(mlir::AsmPrinter &p, - cir::TargetAddressSpaceAttr attr) { - p << "target_address_space(" << attr.getValue().getUInt() << ")"; +void printAddressSpaceValue(mlir::AsmPrinter &p, + mlir::ptr::MemorySpaceAttrInterface attr) { + if (!attr) + return; + + if (auto language = dyn_cast<cir::LangAddressSpaceAttr>(attr)) { + p << "lang_address_space(" + << cir::stringifyLangAddressSpace(language.getValue()) << ')'; + return; + } + + if (auto target = dyn_cast<cir::TargetAddressSpaceAttr>(attr)) { + p << "target_address_space(" << target.getValue() << ')'; + return; + } + + llvm_unreachable("unexpected address-space attribute kind"); +} + +mlir::ptr::MemorySpaceAttrInterface +cir::toCIRAddressSpaceAttr(mlir::MLIRContext *ctx, clang::LangAS langAS) { + using clang::LangAS; + + if (langAS == LangAS::Default) + return {}; // Default address space is represented as an empty attribute. + + if (clang::isTargetAddressSpace(langAS)) { + unsigned targetAS = clang::toTargetAddressSpace(langAS); + return cir::TargetAddressSpaceAttr::get(ctx, targetAS); + } + + return cir::LangAddressSpaceAttr::get(ctx, toCIRLangAddressSpace(langAS)); +} + +bool cir::isMatchingAddressSpace(mlir::MLIRContext &ctx, + mlir::ptr::MemorySpaceAttrInterface cirAS, + clang::LangAS as) { + return cir::toCIRAddressSpaceAttr(&ctx, as) == cirAS; +} + +//===----------------------------------------------------------------------===// +// PointerType Definitions +//===----------------------------------------------------------------------===// + +mlir::LogicalResult cir::PointerType::verify( + llvm::function_ref<mlir::InFlightDiagnostic()> emitError, + mlir::Type pointee, mlir::ptr::MemorySpaceAttrInterface addrSpace) { + if (addrSpace) { + if (!isSupportedCIRMemorySpaceAttr(addrSpace)) { + return emitError() << "unsupported address space attribute; expected " + "'target_address_space' or 'lang_address_space'"; + } + } + + return success(); } //===----------------------------------------------------------------------===// diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index 3318638b8a03d..d2580a7e9fcb4 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -21,12 +21,14 @@ #include "mlir/Dialect/Func/IR/FuncOps.h" #include "mlir/Dialect/LLVMIR/LLVMDialect.h" #include "mlir/Dialect/LLVMIR/LLVMTypes.h" +#include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "mlir/IR/BuiltinAttributes.h" #include "mlir/IR/BuiltinDialect.h" #include "mlir/IR/BuiltinOps.h" #include "mlir/IR/Types.h" #include "mlir/Pass/Pass.h" #include "mlir/Pass/PassManager.h" +#include "mlir/Support/LLVM.h" #include "mlir/Target/LLVMIR/Dialect/Builtin/BuiltinToLLVMIRTranslation.h" #include "mlir/Target/LLVMIR/Dialect/LLVMIR/LLVMToLLVMIRTranslation.h" #include "mlir/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.h" @@ -41,6 +43,7 @@ #include "clang/CIR/Passes.h" #include "llvm/ADT/TypeSwitch.h" #include "llvm/IR/Module.h" +#include "llvm/Support/Casting.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/TimeProfiler.h" @@ -3254,9 +3257,17 @@ mlir::LogicalResult CIRToLLVMSelectOpLowering::matchAndRewrite( static void prepareTypeConverter(mlir::LLVMTypeConverter &converter, mlir::DataLayout &dataLayout) { converter.addConversion([&](cir::PointerType type) -> mlir::Type { - unsigned addrSpace = - type.getAddrSpace() ? type.getAddrSpace().getValue().getUInt() : 0; - return mlir::LLVM::LLVMPointerType::get(type.getContext(), addrSpace); + mlir::ptr::MemorySpaceAttrInterface addrSpaceAttr = type.getAddrSpace(); + unsigned numericAS = 0; + + if (auto langAsAttr = + mlir::dyn_cast_if_present<cir::LangAddressSpaceAttr>(addrSpaceAttr)) + llvm_unreachable("lowering LangAddressSpaceAttr NYI"); + else if (auto langAsAttr = + mlir::dyn_cast_if_present<cir::TargetAddressSpaceAttr>( + addrSpaceAttr)) + numericAS = langAsAttr.getValue(); + return mlir::LLVM::LLVMPointerType::get(type.getContext(), numericAS); }); converter.addConversion([&](cir::VPtrType type) -> mlir::Type { assert(!cir::MissingFeatures::addressSpace()); diff --git a/clang/test/CIR/IR/address-space.cir b/clang/test/CIR/IR/address-space.cir new file mode 100644 index 0000000000000..9a729c934bc11 --- /dev/null +++ b/clang/test/CIR/IR/address-space.cir @@ -0,0 +1,41 @@ +// RUN: cir-opt %s --verify-roundtrip | FileCheck %s + +!s32i = !cir.int<s, 32> + +module { + cir.func @target_address_space_ptr(%p: !cir.ptr<!s32i, target_address_space(1)>) { + cir.return + } + + cir.func @lang_address_space_offload_local(%p: !cir.ptr<!s32i, lang_address_space(offload_local)>) { + cir.return + } + + cir.func @lang_address_space_offload_global(%p: !cir.ptr<!s32i, lang_address_space(offload_global)>) { + cir.return + } + + cir.func @lang_address_space_offload_constant(%p: !cir.ptr<!s32i, lang_address_space(offload_constant)>) { + cir.return + } + + cir.func @lang_address_space_offload_private(%p: !cir.ptr<!s32i, lang_address_space(offload_private)>) { + cir.return + } + + cir.func @lang_address_space_offload_generic(%p: !cir.ptr<!s32i, lang_address_space(offload_generic)>) { + cir.return + } + + cir.func @default_address_space(%p: !cir.ptr<!s32i>) { + cir.return + } +} + +// CHECK: cir.func @target_address_space_ptr(%arg0: !cir.ptr<!s32i, target_address_space(1)>) +// CHECK: cir.func @lang_address_space_offload_local(%arg0: !cir.ptr<!s32i, lang_address_space(offload_local)>) +// CHECK: cir.func @lang_address_space_offload_global(%arg0: !cir.ptr<!s32i, lang_address_space(offload_global)>) +// CHECK: cir.func @lang_address_space_offload_constant(%arg0: !cir.ptr<!s32i, lang_address_space(offload_constant)>) +// CHECK: cir.func @lang_address_space_offload_private(%arg0: !cir.ptr<!s32i, lang_address_space(offload_private)>) +// CHECK: cir.func @lang_address_space_offload_generic(%arg0: !cir.ptr<!s32i, lang_address_space(offload_generic)>) +// CHECK: cir.func @default_address_space(%arg0: !cir.ptr<!s32i>) diff --git a/clang/test/CIR/IR/invalid-addrspace.cir b/clang/test/CIR/IR/invalid-addrspace.cir index 4b6a388b1e4a8..d38868f1febf0 100644 --- a/clang/test/CIR/IR/invalid-addrspace.cir +++ b/clang/test/CIR/IR/invalid-addrspace.cir @@ -3,7 +3,7 @@ // ----- !u64i = !cir.int<u, 64> -// expected-error @below {{expected 'target_address_space'}} +// expected-error @+1 {{unknown address space specifier 'foobar'; expected 'target_address_space' or 'lang_address_space'}} cir.func @address_space1(%p : !cir.ptr<!u64i, foobar>) { cir.return } @@ -11,6 +11,7 @@ cir.func @address_space1(%p : !cir.ptr<!u64i, foobar>) { // ----- !u64i = !cir.int<u, 64> +// expected-error@below {{expected '(' after 'target_address_space'}} // expected-error@below {{expected '('}} cir.func @address_space2(%p : !cir.ptr<!u64i, target_address_space>) { cir.return @@ -19,8 +20,33 @@ cir.func @address_space2(%p : !cir.ptr<!u64i, target_address_space>) { // ----- !u64i = !cir.int<u, 64> -// expected-error@+2 {{expected integer value}} -// expected-error@below {{expected integer address space value}} +// expected-error@below {{expected target address space value}} +// expected-error@below {{expected integer value}} cir.func @address_space3(%p : !cir.ptr<!u64i, target_address_space()>) { cir.return } + +// ----- + +!u64i = !cir.int<u, 64> +// expected-error@below {{expected '(' after 'lang_address_space'}} +// expected-error@below {{expected '('}} +cir.func @lang_address_space_no_parens(%p : !cir.ptr<!u64i, lang_address_space>) { + cir.return +} + +// ----- + +!u64i = !cir.int<u, 64> +// expected-error@+1 {{expected keyword for language address space kind}} +cir.func @lang_address_space_empty(%p : !cir.ptr<!u64i, lang_address_space()>) { + cir.return +} + +// ----- + +!u64i = !cir.int<u, 64> +// expected-error@+1 {{expected one of [default, offload_private, offload_local, offload_global, offload_constant, offload_generic] for language address space kind}} +cir.func @lang_address_space_invalid(%p : !cir.ptr<!u64i, lang_address_space(foobar)>) { + cir.return +} >From d8192fd72ee42425846031dd5894c3d2c40e3e0a Mon Sep 17 00:00:00 2001 From: David Rivera <[email protected]> Date: Wed, 4 Feb 2026 16:26:53 -0500 Subject: [PATCH 2/9] Address first round of comments --- .../clang/CIR/Dialect/Builder/CIRBaseBuilder.h | 2 +- clang/include/clang/CIR/Dialect/IR/CIRTypes.h | 5 ++--- clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp | 4 ++-- clang/lib/CIR/CodeGen/CIRGenExpr.cpp | 2 +- clang/lib/CIR/Dialect/IR/CIRTypes.cpp | 11 +++++------ 5 files changed, 11 insertions(+), 13 deletions(-) diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h index f62dedb1f3f00..e90b403cbe488 100644 --- a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h +++ b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h @@ -167,7 +167,7 @@ class CIRBaseBuilderTy : public mlir::OpBuilder { return getPointerTo(ty); mlir::ptr::MemorySpaceAttrInterface addrSpaceAttr = - cir::toCIRAddressSpaceAttr(getContext(), langAS); + cir::toCIRAddressSpaceAttr(*getContext(), langAS); return getPointerTo(ty, addrSpaceAttr); } diff --git a/clang/include/clang/CIR/Dialect/IR/CIRTypes.h b/clang/include/clang/CIR/Dialect/IR/CIRTypes.h index eee4140ba2801..02545ea412a52 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRTypes.h +++ b/clang/include/clang/CIR/Dialect/IR/CIRTypes.h @@ -48,14 +48,13 @@ bool isSized(mlir::Type ty); cir::LangAddressSpace toCIRLangAddressSpace(clang::LangAS langAS); // Compare a CIR memory space attribute with a Clang LangAS. -bool isMatchingAddressSpace(mlir::MLIRContext &ctx, - mlir::ptr::MemorySpaceAttrInterface cirAS, +bool isMatchingAddressSpace(mlir::ptr::MemorySpaceAttrInterface cirAS, clang::LangAS as); /// Convert an AST LangAS to the appropriate CIR address space attribute /// interface. mlir::ptr::MemorySpaceAttrInterface -toCIRAddressSpaceAttr(mlir::MLIRContext *ctx, clang::LangAS langAS); +toCIRAddressSpaceAttr(mlir::MLIRContext &ctx, clang::LangAS langAS); bool isSupportedCIRMemorySpaceAttr( mlir::ptr::MemorySpaceAttrInterface memorySpace); diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp index 1fc72aa43144c..dcef7c45dc686 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp @@ -378,10 +378,10 @@ static RValue emitBuiltinAlloca(CIRGenFunction &cgf, const CallExpr *e, // builtin / dynamic alloca we have to handle it here. if (!cir::isMatchingAddressSpace( - cgf.getMLIRContext(), cgf.getCIRAllocaAddressSpace(), + cgf.getCIRAllocaAddressSpace(), e->getType()->getPointeeType().getAddressSpace())) { cgf.cgm.errorNYI(e->getSourceRange(), - "Non-default address space for alloca"); + "Address Space Cast for builtin alloca"); } // Bitcast the alloca to the expected type. diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp index 20f656e4471e2..1ba3bb274095c 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp @@ -1458,7 +1458,7 @@ LValue CIRGenFunction::emitCastLValue(const CastExpr *e) { clang::LangAS srcLangAS = e->getSubExpr()->getType().getAddressSpace(); mlir::ptr::MemorySpaceAttrInterface srcAS; if (clang::isTargetAddressSpace(srcLangAS)) - srcAS = cir::toCIRAddressSpaceAttr(&getMLIRContext(), srcLangAS); + srcAS = cir::toCIRAddressSpaceAttr(getMLIRContext(), srcLangAS); else cgm.errorNYI( e->getSourceRange(), diff --git a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp index 42445a07864d8..eb39207e5f081 100644 --- a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp @@ -1058,7 +1058,7 @@ void printAddressSpaceValue(mlir::AsmPrinter &p, } mlir::ptr::MemorySpaceAttrInterface -cir::toCIRAddressSpaceAttr(mlir::MLIRContext *ctx, clang::LangAS langAS) { +cir::toCIRAddressSpaceAttr(mlir::MLIRContext &ctx, clang::LangAS langAS) { using clang::LangAS; if (langAS == LangAS::Default) @@ -1066,16 +1066,15 @@ cir::toCIRAddressSpaceAttr(mlir::MLIRContext *ctx, clang::LangAS langAS) { if (clang::isTargetAddressSpace(langAS)) { unsigned targetAS = clang::toTargetAddressSpace(langAS); - return cir::TargetAddressSpaceAttr::get(ctx, targetAS); + return cir::TargetAddressSpaceAttr::get(&ctx, targetAS); } - return cir::LangAddressSpaceAttr::get(ctx, toCIRLangAddressSpace(langAS)); + return cir::LangAddressSpaceAttr::get(&ctx, toCIRLangAddressSpace(langAS)); } -bool cir::isMatchingAddressSpace(mlir::MLIRContext &ctx, - mlir::ptr::MemorySpaceAttrInterface cirAS, +bool cir::isMatchingAddressSpace(mlir::ptr::MemorySpaceAttrInterface cirAS, clang::LangAS as) { - return cir::toCIRAddressSpaceAttr(&ctx, as) == cirAS; + return cir::toCIRAddressSpaceAttr(*cirAS.getContext(), as) == cirAS; } //===----------------------------------------------------------------------===// >From ad530e815cd3f451a80a27a0d75dac2517a6fac4 Mon Sep 17 00:00:00 2001 From: David Rivera <[email protected]> Date: Wed, 4 Feb 2026 16:51:19 -0500 Subject: [PATCH 3/9] test work now yo --- clang/lib/CIR/Dialect/IR/CIRTypes.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp index eb39207e5f081..659862ef208eb 100644 --- a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp @@ -1074,6 +1074,8 @@ cir::toCIRAddressSpaceAttr(mlir::MLIRContext &ctx, clang::LangAS langAS) { bool cir::isMatchingAddressSpace(mlir::ptr::MemorySpaceAttrInterface cirAS, clang::LangAS as) { + if (!cirAS) + return as == clang::LangAS::Default; return cir::toCIRAddressSpaceAttr(*cirAS.getContext(), as) == cirAS; } >From a1a56fffd0e281fc8ec0eed6076511fd9b8af3e4 Mon Sep 17 00:00:00 2001 From: David Rivera <[email protected]> Date: Wed, 25 Feb 2026 21:51:21 -0500 Subject: [PATCH 4/9] nit: Handle target AS value as unsigned int --- clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp index dcef7c45dc686..86d34be0a311c 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp @@ -825,7 +825,7 @@ decodeFixedType(CIRGenFunction &cgf, case IITDescriptor::Pointer: { mlir::Builder builder(context); auto addrSpace = cir::TargetAddressSpaceAttr::get( - context, builder.getUI32IntegerAttr(descriptor.Pointer_AddressSpace)); + context, descriptor.Pointer_AddressSpace); return cir::PointerType::get(cir::VoidType::get(context), addrSpace); } default: >From f7be6a8bf4436a1266097c522744bef04a3becc3 Mon Sep 17 00:00:00 2001 From: David Rivera <[email protected]> Date: Wed, 25 Feb 2026 21:51:43 -0500 Subject: [PATCH 5/9] Handle empty AS attr as LangAs::Default and Normalize LangAs::Default a to null in PointerType --- .../clang/CIR/Dialect/Builder/CIRBaseBuilder.h | 2 -- clang/include/clang/CIR/Dialect/IR/CIRTypes.h | 4 ++++ clang/include/clang/CIR/Dialect/IR/CIRTypes.td | 4 ++++ clang/lib/CIR/Dialect/IR/CIRTypes.cpp | 15 +++++++++++++-- 4 files changed, 21 insertions(+), 4 deletions(-) diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h index e90b403cbe488..32d0921d15363 100644 --- a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h +++ b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h @@ -157,8 +157,6 @@ class CIRBaseBuilderTy : public mlir::OpBuilder { cir::PointerType getPointerTo(mlir::Type ty, mlir::ptr::MemorySpaceAttrInterface as) { - if (!as) - return cir::PointerType::get(ty); return cir::PointerType::get(ty, as); } diff --git a/clang/include/clang/CIR/Dialect/IR/CIRTypes.h b/clang/include/clang/CIR/Dialect/IR/CIRTypes.h index 02545ea412a52..465532cc18436 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRTypes.h +++ b/clang/include/clang/CIR/Dialect/IR/CIRTypes.h @@ -56,6 +56,10 @@ bool isMatchingAddressSpace(mlir::ptr::MemorySpaceAttrInterface cirAS, mlir::ptr::MemorySpaceAttrInterface toCIRAddressSpaceAttr(mlir::MLIRContext &ctx, clang::LangAS langAS); +/// Normalize LangAddressSpace::Default to null (empty attribute). +mlir::ptr::MemorySpaceAttrInterface +skipDefaultAddressSpace(mlir::ptr::MemorySpaceAttrInterface addrSpace); + bool isSupportedCIRMemorySpaceAttr( mlir::ptr::MemorySpaceAttrInterface memorySpace); diff --git a/clang/include/clang/CIR/Dialect/IR/CIRTypes.td b/clang/include/clang/CIR/Dialect/IR/CIRTypes.td index 9b01ee54f8afe..913802a08a89b 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRTypes.td +++ b/clang/include/clang/CIR/Dialect/IR/CIRTypes.td @@ -260,11 +260,15 @@ def CIR_PointerType : CIR_Type<"Pointer", "ptr", [ TypeBuilderWithInferredContext<(ins "mlir::Type":$pointee, CArg<"mlir::ptr::MemorySpaceAttrInterface", "{}">:$addrSpace), [{ + // Drop default address space and replace with empty attribute. + addrSpace = cir::skipDefaultAddressSpace(addrSpace); return $_get(pointee.getContext(), pointee, addrSpace); }]>, TypeBuilder<(ins "mlir::Type":$pointee, CArg<"mlir::ptr::MemorySpaceAttrInterface", "{}">:$addrSpace), [{ + // Drop default address space and replace with empty attribute. + addrSpace = cir::skipDefaultAddressSpace(addrSpace); return $_get($_ctxt, pointee, addrSpace); }]> ]; diff --git a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp index 659862ef208eb..442f2630fc879 100644 --- a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp @@ -1057,12 +1057,21 @@ void printAddressSpaceValue(mlir::AsmPrinter &p, llvm_unreachable("unexpected address-space attribute kind"); } +mlir::ptr::MemorySpaceAttrInterface +cir::skipDefaultAddressSpace(mlir::ptr::MemorySpaceAttrInterface addrSpace) { + if (auto langAS = + mlir::dyn_cast_if_present<cir::LangAddressSpaceAttr>(addrSpace)) + if (langAS.getValue() == cir::LangAddressSpace::Default) + return {}; + return addrSpace; +} + mlir::ptr::MemorySpaceAttrInterface cir::toCIRAddressSpaceAttr(mlir::MLIRContext &ctx, clang::LangAS langAS) { using clang::LangAS; if (langAS == LangAS::Default) - return {}; // Default address space is represented as an empty attribute. + return cir::LangAddressSpaceAttr::get(&ctx, cir::LangAddressSpace::Default); if (clang::isTargetAddressSpace(langAS)) { unsigned targetAS = clang::toTargetAddressSpace(langAS); @@ -1076,7 +1085,9 @@ bool cir::isMatchingAddressSpace(mlir::ptr::MemorySpaceAttrInterface cirAS, clang::LangAS as) { if (!cirAS) return as == clang::LangAS::Default; - return cir::toCIRAddressSpaceAttr(*cirAS.getContext(), as) == cirAS; + mlir::ptr::MemorySpaceAttrInterface expected = skipDefaultAddressSpace( + toCIRAddressSpaceAttr(*cirAS.getContext(), as)); + return expected == cirAS; } //===----------------------------------------------------------------------===// >From b75222ca522a8e4a2b01677e18d922b47d456df0 Mon Sep 17 00:00:00 2001 From: David Rivera <[email protected]> Date: Thu, 26 Feb 2026 00:28:01 -0500 Subject: [PATCH 6/9] correct nits --- clang/lib/CIR/CodeGen/TargetInfo.h | 4 +++- clang/lib/CIR/Dialect/IR/CIRTypes.cpp | 4 ++-- clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp | 4 ++-- 3 files changed, 7 insertions(+), 5 deletions(-) diff --git a/clang/lib/CIR/CodeGen/TargetInfo.h b/clang/lib/CIR/CodeGen/TargetInfo.h index b60ba22af64ce..f4792d5309e36 100644 --- a/clang/lib/CIR/CodeGen/TargetInfo.h +++ b/clang/lib/CIR/CodeGen/TargetInfo.h @@ -19,6 +19,7 @@ #include "mlir/Dialect/Ptr/IR/MemorySpaceInterfaces.h" #include "clang/Basic/AddressSpaces.h" #include "clang/CIR/Dialect/IR/CIRAttrs.h" +#include "clang/CIR/Dialect/IR/CIROpsEnums.h" #include <memory> #include <utility> @@ -50,7 +51,8 @@ class TargetCIRGenInfo { /// Get the address space for alloca. virtual mlir::ptr::MemorySpaceAttrInterface getCIRAllocaAddressSpace() const { - return {}; + return cir::LangAddressSpaceAttr::get(&info->cgt.getMLIRContext(), + cir::LangAddressSpace::Default); } /// Determine whether a call to an unprototyped functions under diff --git a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp index 442f2630fc879..2739929b00a71 100644 --- a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp @@ -1085,8 +1085,8 @@ bool cir::isMatchingAddressSpace(mlir::ptr::MemorySpaceAttrInterface cirAS, clang::LangAS as) { if (!cirAS) return as == clang::LangAS::Default; - mlir::ptr::MemorySpaceAttrInterface expected = skipDefaultAddressSpace( - toCIRAddressSpaceAttr(*cirAS.getContext(), as)); + mlir::ptr::MemorySpaceAttrInterface expected = + skipDefaultAddressSpace(toCIRAddressSpaceAttr(*cirAS.getContext(), as)); return expected == cirAS; } diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index d2580a7e9fcb4..03085ad29ab78 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -3263,10 +3263,10 @@ static void prepareTypeConverter(mlir::LLVMTypeConverter &converter, if (auto langAsAttr = mlir::dyn_cast_if_present<cir::LangAddressSpaceAttr>(addrSpaceAttr)) llvm_unreachable("lowering LangAddressSpaceAttr NYI"); - else if (auto langAsAttr = + else if (auto targetAsAttr = mlir::dyn_cast_if_present<cir::TargetAddressSpaceAttr>( addrSpaceAttr)) - numericAS = langAsAttr.getValue(); + numericAS = targetAsAttr.getValue(); return mlir::LLVM::LLVMPointerType::get(type.getContext(), numericAS); }); converter.addConversion([&](cir::VPtrType type) -> mlir::Type { >From 81c652cbb344818d0a52d63bd61a0da083b9606a Mon Sep 17 00:00:00 2001 From: David Rivera <[email protected]> Date: Thu, 26 Feb 2026 01:19:31 -0500 Subject: [PATCH 7/9] fix matching as check --- clang/lib/CIR/Dialect/IR/CIRTypes.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp index 2739929b00a71..452f36d51c3a3 100644 --- a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp @@ -1083,6 +1083,7 @@ cir::toCIRAddressSpaceAttr(mlir::MLIRContext &ctx, clang::LangAS langAS) { bool cir::isMatchingAddressSpace(mlir::ptr::MemorySpaceAttrInterface cirAS, clang::LangAS as) { + cirAS = skipDefaultAddressSpace(cirAS); if (!cirAS) return as == clang::LangAS::Default; mlir::ptr::MemorySpaceAttrInterface expected = >From cc9f25d032ceb7e2fa57a51da0af0e6faaa9b927 Mon Sep 17 00:00:00 2001 From: David Rivera <[email protected]> Date: Fri, 27 Feb 2026 21:43:46 -0500 Subject: [PATCH 8/9] rename normalize AS function --- clang/include/clang/CIR/Dialect/IR/CIRTypes.h | 2 +- clang/include/clang/CIR/Dialect/IR/CIRTypes.td | 4 ++-- clang/lib/CIR/Dialect/IR/CIRTypes.cpp | 6 +++--- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/clang/include/clang/CIR/Dialect/IR/CIRTypes.h b/clang/include/clang/CIR/Dialect/IR/CIRTypes.h index 465532cc18436..9988a6fdd4b8f 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRTypes.h +++ b/clang/include/clang/CIR/Dialect/IR/CIRTypes.h @@ -58,7 +58,7 @@ toCIRAddressSpaceAttr(mlir::MLIRContext &ctx, clang::LangAS langAS); /// Normalize LangAddressSpace::Default to null (empty attribute). mlir::ptr::MemorySpaceAttrInterface -skipDefaultAddressSpace(mlir::ptr::MemorySpaceAttrInterface addrSpace); +normalizeDefaultAddressSpace(mlir::ptr::MemorySpaceAttrInterface addrSpace); bool isSupportedCIRMemorySpaceAttr( mlir::ptr::MemorySpaceAttrInterface memorySpace); diff --git a/clang/include/clang/CIR/Dialect/IR/CIRTypes.td b/clang/include/clang/CIR/Dialect/IR/CIRTypes.td index 913802a08a89b..450c02135e033 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRTypes.td +++ b/clang/include/clang/CIR/Dialect/IR/CIRTypes.td @@ -261,14 +261,14 @@ def CIR_PointerType : CIR_Type<"Pointer", "ptr", [ "mlir::Type":$pointee, CArg<"mlir::ptr::MemorySpaceAttrInterface", "{}">:$addrSpace), [{ // Drop default address space and replace with empty attribute. - addrSpace = cir::skipDefaultAddressSpace(addrSpace); + addrSpace = cir::normalizeDefaultAddressSpace(addrSpace); return $_get(pointee.getContext(), pointee, addrSpace); }]>, TypeBuilder<(ins "mlir::Type":$pointee, CArg<"mlir::ptr::MemorySpaceAttrInterface", "{}">:$addrSpace), [{ // Drop default address space and replace with empty attribute. - addrSpace = cir::skipDefaultAddressSpace(addrSpace); + addrSpace = cir::normalizeDefaultAddressSpace(addrSpace); return $_get($_ctxt, pointee, addrSpace); }]> ]; diff --git a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp index 452f36d51c3a3..92204f2319373 100644 --- a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp @@ -1058,7 +1058,7 @@ void printAddressSpaceValue(mlir::AsmPrinter &p, } mlir::ptr::MemorySpaceAttrInterface -cir::skipDefaultAddressSpace(mlir::ptr::MemorySpaceAttrInterface addrSpace) { +cir::normalizeDefaultAddressSpace(mlir::ptr::MemorySpaceAttrInterface addrSpace) { if (auto langAS = mlir::dyn_cast_if_present<cir::LangAddressSpaceAttr>(addrSpace)) if (langAS.getValue() == cir::LangAddressSpace::Default) @@ -1083,11 +1083,11 @@ cir::toCIRAddressSpaceAttr(mlir::MLIRContext &ctx, clang::LangAS langAS) { bool cir::isMatchingAddressSpace(mlir::ptr::MemorySpaceAttrInterface cirAS, clang::LangAS as) { - cirAS = skipDefaultAddressSpace(cirAS); + cirAS = normalizeDefaultAddressSpace(cirAS); if (!cirAS) return as == clang::LangAS::Default; mlir::ptr::MemorySpaceAttrInterface expected = - skipDefaultAddressSpace(toCIRAddressSpaceAttr(*cirAS.getContext(), as)); + normalizeDefaultAddressSpace(toCIRAddressSpaceAttr(*cirAS.getContext(), as)); return expected == cirAS; } >From 6f2706021d595dc6c5fe2fdeaac653471e5b101f Mon Sep 17 00:00:00 2001 From: David Rivera <[email protected]> Date: Fri, 27 Feb 2026 22:14:27 -0500 Subject: [PATCH 9/9] fix fmt --- clang/lib/CIR/Dialect/IR/CIRTypes.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp index 92204f2319373..80dce3d3266b5 100644 --- a/clang/lib/CIR/Dialect/IR/CIRTypes.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRTypes.cpp @@ -1057,8 +1057,8 @@ void printAddressSpaceValue(mlir::AsmPrinter &p, llvm_unreachable("unexpected address-space attribute kind"); } -mlir::ptr::MemorySpaceAttrInterface -cir::normalizeDefaultAddressSpace(mlir::ptr::MemorySpaceAttrInterface addrSpace) { +mlir::ptr::MemorySpaceAttrInterface cir::normalizeDefaultAddressSpace( + mlir::ptr::MemorySpaceAttrInterface addrSpace) { if (auto langAS = mlir::dyn_cast_if_present<cir::LangAddressSpaceAttr>(addrSpace)) if (langAS.getValue() == cir::LangAddressSpace::Default) @@ -1086,8 +1086,8 @@ bool cir::isMatchingAddressSpace(mlir::ptr::MemorySpaceAttrInterface cirAS, cirAS = normalizeDefaultAddressSpace(cirAS); if (!cirAS) return as == clang::LangAS::Default; - mlir::ptr::MemorySpaceAttrInterface expected = - normalizeDefaultAddressSpace(toCIRAddressSpaceAttr(*cirAS.getContext(), as)); + mlir::ptr::MemorySpaceAttrInterface expected = normalizeDefaultAddressSpace( + toCIRAddressSpaceAttr(*cirAS.getContext(), as)); return expected == cirAS; } _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
