[Mlir-commits] [mlir] [MLIR][DLTI] Add mangling style (PR #125875)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Fri Feb 21 19:40:01 PST 2025
https://github.com/ghehg updated https://github.com/llvm/llvm-project/pull/125875
>From 80959a89c2b78a6af960883c1e7c22841354e2ba Mon Sep 17 00:00:00 2001
From: ghehg <he.guojin at gmail.com>
Date: Wed, 5 Feb 2025 07:48:31 -0800
Subject: [PATCH] rebase
---
mlir/include/mlir/Dialect/DLTI/DLTIAttrs.td | 3 +++
mlir/include/mlir/Dialect/DLTI/DLTIBase.td | 3 +++
.../mlir/Interfaces/DataLayoutInterfaces.h | 9 +++++++
.../mlir/Interfaces/DataLayoutInterfaces.td | 18 +++++++++++++
mlir/lib/Dialect/DLTI/DLTI.cpp | 9 ++++++-
mlir/lib/Interfaces/DataLayoutInterfaces.cpp | 27 +++++++++++++++++++
mlir/lib/Target/LLVMIR/DataLayoutImporter.cpp | 22 +++++++++++++++
mlir/lib/Target/LLVMIR/DataLayoutImporter.h | 4 +++
mlir/lib/Target/LLVMIR/ModuleTranslation.cpp | 5 ++++
mlir/test/Target/LLVMIR/Import/data-layout.ll | 1 +
.../Target/LLVMIR/Import/import-failure.ll | 5 ++++
mlir/test/Target/LLVMIR/data-layout.mlir | 2 ++
.../lib/Dialect/DLTI/TestDataLayoutQuery.cpp | 5 ++++
.../Interfaces/DataLayoutInterfacesTest.cpp | 4 +++
14 files changed, 116 insertions(+), 1 deletion(-)
diff --git a/mlir/include/mlir/Dialect/DLTI/DLTIAttrs.td b/mlir/include/mlir/Dialect/DLTI/DLTIAttrs.td
index d54b3191eed7e..9bede41a83374 100644
--- a/mlir/include/mlir/Dialect/DLTI/DLTIAttrs.td
+++ b/mlir/include/mlir/Dialect/DLTI/DLTIAttrs.td
@@ -77,6 +77,9 @@ def DLTI_DataLayoutSpecAttr :
/// Returns the alloca memory space identifier.
StringAttr getAllocaMemorySpaceIdentifier(MLIRContext *context) const;
+ /// Returns the mangling style identifier.
+ StringAttr getManglingStyleIdentifier(MLIRContext *context) const;
+
/// Returns the program memory space identifier.
StringAttr getProgramMemorySpaceIdentifier(MLIRContext *context) const;
diff --git a/mlir/include/mlir/Dialect/DLTI/DLTIBase.td b/mlir/include/mlir/Dialect/DLTI/DLTIBase.td
index f84149c43e0fc..b1f54c608e03e 100644
--- a/mlir/include/mlir/Dialect/DLTI/DLTIBase.td
+++ b/mlir/include/mlir/Dialect/DLTI/DLTIBase.td
@@ -49,6 +49,9 @@ def DLTI_Dialect : Dialect {
constexpr const static ::llvm::StringLiteral
kDataLayoutEndiannessLittle = "little";
+ constexpr const static ::llvm::StringLiteral
+ kDataLayoutManglingStyleKey = "dlti.mangling_style";
+
constexpr const static ::llvm::StringLiteral
kDataLayoutAllocaMemorySpaceKey = "dlti.alloca_memory_space";
diff --git a/mlir/include/mlir/Interfaces/DataLayoutInterfaces.h b/mlir/include/mlir/Interfaces/DataLayoutInterfaces.h
index 7a7b659724f86..33fadf842cef1 100644
--- a/mlir/include/mlir/Interfaces/DataLayoutInterfaces.h
+++ b/mlir/include/mlir/Interfaces/DataLayoutInterfaces.h
@@ -78,6 +78,10 @@ Attribute getDefaultEndianness(DataLayoutEntryInterface entry);
/// DataLayoutInterface if specified, otherwise returns the default.
Attribute getDefaultAllocaMemorySpace(DataLayoutEntryInterface entry);
+/// Default handler for mangling style request. Dispatches to the
+/// DataLayoutInterface if specified, otherwise returns the default.
+Attribute getDefaultManglingStyle(DataLayoutEntryInterface entry);
+
/// Default handler for program memory space request. Dispatches to the
/// DataLayoutInterface if specified, otherwise returns the default.
Attribute getDefaultProgramMemorySpace(DataLayoutEntryInterface entry);
@@ -230,6 +234,9 @@ class DataLayout {
/// Returns the memory space used for AllocaOps.
Attribute getAllocaMemorySpace() const;
+ /// Returns the mangling style.
+ Attribute getManglingStyle() const;
+
/// Returns the memory space used for program memory operations.
Attribute getProgramMemorySpace() const;
@@ -276,6 +283,8 @@ class DataLayout {
/// Cache for the endianness.
mutable std::optional<Attribute> endianness;
+ /// Cache for the mangling style.
+ mutable std::optional<Attribute> manglingStyle;
/// Cache for alloca, global, and program memory spaces.
mutable std::optional<Attribute> allocaMemorySpace;
mutable std::optional<Attribute> programMemorySpace;
diff --git a/mlir/include/mlir/Interfaces/DataLayoutInterfaces.td b/mlir/include/mlir/Interfaces/DataLayoutInterfaces.td
index 0d09b92928fe3..8626fb0709a24 100644
--- a/mlir/include/mlir/Interfaces/DataLayoutInterfaces.td
+++ b/mlir/include/mlir/Interfaces/DataLayoutInterfaces.td
@@ -153,6 +153,12 @@ def DataLayoutSpecInterface : AttrInterface<"DataLayoutSpecInterface", [DLTIQuer
/*methodName=*/"getGlobalMemorySpaceIdentifier",
/*args=*/(ins "::mlir::MLIRContext *":$context)
>,
+ InterfaceMethod<
+ /*description=*/"Returns the mangling style identifier.",
+ /*retTy=*/"::mlir::StringAttr",
+ /*methodName=*/"getManglingStyleIdentifier",
+ /*args=*/(ins "::mlir::MLIRContext *":$context)
+ >,
InterfaceMethod<
/*description=*/"Returns the stack alignment identifier.",
/*retTy=*/"::mlir::StringAttr",
@@ -481,6 +487,18 @@ def DataLayoutOpInterface : OpInterface<"DataLayoutOpInterface"> {
return ::mlir::detail::getDefaultAllocaMemorySpace(entry);
}]
>,
+ StaticInterfaceMethod<
+ /*description=*/"Returns the mangling style computed "
+ "using the relevant entries. The data layout object "
+ "can be used for recursive queries.",
+ /*retTy=*/"::mlir::Attribute",
+ /*methodName=*/"getManglingStyle",
+ /*args=*/(ins "::mlir::DataLayoutEntryInterface":$entry),
+ /*methodBody=*/"",
+ /*defaultImplementation=*/[{
+ return ::mlir::detail::getDefaultManglingStyle(entry);
+ }]
+ >,
StaticInterfaceMethod<
/*description=*/"Returns the memory space used by the ABI computed "
"using the relevant entries. The data layout object "
diff --git a/mlir/lib/Dialect/DLTI/DLTI.cpp b/mlir/lib/Dialect/DLTI/DLTI.cpp
index 70e05cb4cb383..94855cc91de54 100644
--- a/mlir/lib/Dialect/DLTI/DLTI.cpp
+++ b/mlir/lib/Dialect/DLTI/DLTI.cpp
@@ -397,6 +397,12 @@ DataLayoutSpecAttr::getGlobalMemorySpaceIdentifier(MLIRContext *context) const {
DLTIDialect::kDataLayoutGlobalMemorySpaceKey);
}
+StringAttr
+DataLayoutSpecAttr::getManglingStyleIdentifier(MLIRContext *context) const {
+ return Builder(context).getStringAttr(
+ DLTIDialect::kDataLayoutManglingStyleKey);
+}
+
StringAttr
DataLayoutSpecAttr::getStackAlignmentIdentifier(MLIRContext *context) const {
return Builder(context).getStringAttr(
@@ -606,7 +612,8 @@ class TargetDataLayoutInterface : public DataLayoutDialectInterface {
if (entryName == DLTIDialect::kDataLayoutAllocaMemorySpaceKey ||
entryName == DLTIDialect::kDataLayoutProgramMemorySpaceKey ||
entryName == DLTIDialect::kDataLayoutGlobalMemorySpaceKey ||
- entryName == DLTIDialect::kDataLayoutStackAlignmentKey)
+ entryName == DLTIDialect::kDataLayoutStackAlignmentKey ||
+ entryName == DLTIDialect::kDataLayoutManglingStyleKey)
return success();
return emitError(loc) << "unknown data layout entry name: " << entryName;
}
diff --git a/mlir/lib/Interfaces/DataLayoutInterfaces.cpp b/mlir/lib/Interfaces/DataLayoutInterfaces.cpp
index 049d7f123cec8..93f91bdc451f9 100644
--- a/mlir/lib/Interfaces/DataLayoutInterfaces.cpp
+++ b/mlir/lib/Interfaces/DataLayoutInterfaces.cpp
@@ -258,6 +258,17 @@ mlir::detail::getDefaultAllocaMemorySpace(DataLayoutEntryInterface entry) {
return entry.getValue();
}
+// Returns the mangling style if specified in the given entry.
+// If the entry is empty, an empty attribute is returned.
+Attribute
+mlir::detail::getDefaultManglingStyle(DataLayoutEntryInterface entry) {
+ if (entry == DataLayoutEntryInterface()) {
+ return Attribute();
+ }
+
+ return entry.getValue();
+}
+
// Returns the memory space used for the program memory space. if
// specified in the given entry. If the entry is empty the default
// memory space represented by an empty attribute is returned.
@@ -612,6 +623,22 @@ mlir::Attribute mlir::DataLayout::getAllocaMemorySpace() const {
return *allocaMemorySpace;
}
+mlir::Attribute mlir::DataLayout::getManglingStyle() const {
+ checkValid();
+ if (manglingStyle)
+ return *manglingStyle;
+ DataLayoutEntryInterface entry;
+ if (originalLayout)
+ entry = originalLayout.getSpecForIdentifier(
+ originalLayout.getManglingStyleIdentifier(originalLayout.getContext()));
+
+ if (auto iface = dyn_cast_or_null<DataLayoutOpInterface>(scope))
+ manglingStyle = iface.getManglingStyle(entry);
+ else
+ manglingStyle = detail::getDefaultManglingStyle(entry);
+ return *manglingStyle;
+}
+
mlir::Attribute mlir::DataLayout::getProgramMemorySpace() const {
checkValid();
if (programMemorySpace)
diff --git a/mlir/lib/Target/LLVMIR/DataLayoutImporter.cpp b/mlir/lib/Target/LLVMIR/DataLayoutImporter.cpp
index 35fdbc0be22c3..b79ee902ff29f 100644
--- a/mlir/lib/Target/LLVMIR/DataLayoutImporter.cpp
+++ b/mlir/lib/Target/LLVMIR/DataLayoutImporter.cpp
@@ -163,6 +163,21 @@ DataLayoutImporter::tryToEmplaceEndiannessEntry(StringRef endianness,
return success();
}
+LogicalResult DataLayoutImporter::tryToEmplaceManglingStyleEntry(
+ StringRef token, llvm::StringLiteral manglingKey) {
+ auto key = StringAttr::get(context, manglingKey);
+ if (keyEntries.count(key))
+ return success();
+
+ token.consume_front(":");
+ if (token.empty())
+ return failure();
+
+ keyEntries.try_emplace(
+ key, DataLayoutEntryAttr::get(key, StringAttr::get(context, token)));
+ return success();
+}
+
LogicalResult
DataLayoutImporter::tryToEmplaceAddrSpaceEntry(StringRef token,
llvm::StringLiteral spaceKey) {
@@ -254,6 +269,13 @@ void DataLayoutImporter::translateDataLayout(
return;
continue;
}
+ // Parse the mangling style.
+ if (*prefix == "m") {
+ if (failed(tryToEmplaceManglingStyleEntry(
+ token, DLTIDialect::kDataLayoutManglingStyleKey)))
+ return;
+ continue;
+ }
// Parse the global address space.
if (*prefix == "G") {
if (failed(tryToEmplaceAddrSpaceEntry(
diff --git a/mlir/lib/Target/LLVMIR/DataLayoutImporter.h b/mlir/lib/Target/LLVMIR/DataLayoutImporter.h
index 59b60acd24be2..a66402065cb10 100644
--- a/mlir/lib/Target/LLVMIR/DataLayoutImporter.h
+++ b/mlir/lib/Target/LLVMIR/DataLayoutImporter.h
@@ -100,6 +100,10 @@ class DataLayoutImporter {
LogicalResult tryToEmplaceAddrSpaceEntry(StringRef token,
llvm::StringLiteral spaceKey);
+ /// Adds an mangling style entry if there is none yet.
+ LogicalResult tryToEmplaceManglingStyleEntry(StringRef token,
+ llvm::StringLiteral manglingKey);
+
/// Adds a stack alignment entry if there is none yet.
LogicalResult tryToEmplaceStackAlignmentEntry(StringRef token);
diff --git a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp
index 5cd841ee2df91..0b2639cfe721a 100644
--- a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp
+++ b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp
@@ -199,6 +199,11 @@ translateDataLayout(DataLayoutSpecInterface attribute,
layoutStream << "-" << (isLittleEndian ? "e" : "E");
continue;
}
+ if (key.getValue() == DLTIDialect::kDataLayoutManglingStyleKey) {
+ auto value = cast<StringAttr>(entry.getValue());
+ layoutStream << "-m:" << value.getValue();
+ continue;
+ }
if (key.getValue() == DLTIDialect::kDataLayoutProgramMemorySpaceKey) {
auto value = cast<IntegerAttr>(entry.getValue());
uint64_t space = value.getValue().getZExtValue();
diff --git a/mlir/test/Target/LLVMIR/Import/data-layout.ll b/mlir/test/Target/LLVMIR/Import/data-layout.ll
index c397053585e3c..b21043718e19e 100644
--- a/mlir/test/Target/LLVMIR/Import/data-layout.ll
+++ b/mlir/test/Target/LLVMIR/Import/data-layout.ll
@@ -29,6 +29,7 @@ target datalayout = ""
; CHECK-DAG: !llvm.ptr<271> = dense<32> : vector<4xi64>
; CHECK-DAG: !llvm.ptr<272> = dense<64> : vector<4xi64>
; CHECK-DAG: "dlti.stack_alignment" = 128 : i64
+; CHECK-DAG: "dlti.mangling_style" = "e"
target datalayout = "e-m:e-p270:32:64-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
; // -----
diff --git a/mlir/test/Target/LLVMIR/Import/import-failure.ll b/mlir/test/Target/LLVMIR/Import/import-failure.ll
index d929a59284762..80656493a99eb 100644
--- a/mlir/test/Target/LLVMIR/Import/import-failure.ll
+++ b/mlir/test/Target/LLVMIR/Import/import-failure.ll
@@ -354,6 +354,11 @@ declare void @llvm.experimental.noalias.scope.decl(metadata)
; CHECK-SAME: warning: unhandled data layout token: ni:42
target datalayout = "e-ni:42-i64:64"
+; // -----
+; CHECK: import-failure.ll
+; CHECK-SAME: malformed specification, must be of the form "m:<mangling>"
+target datalayout = "e-m-i64:64"
+
; // -----
; CHECK: <unknown>
diff --git a/mlir/test/Target/LLVMIR/data-layout.mlir b/mlir/test/Target/LLVMIR/data-layout.mlir
index 881d6727e2a17..c8aa7ed14b73f 100644
--- a/mlir/test/Target/LLVMIR/data-layout.mlir
+++ b/mlir/test/Target/LLVMIR/data-layout.mlir
@@ -4,6 +4,7 @@
// CHECK: E-
// CHECK: A4-
// CHECK: S128-
+// CHECK: m:e-
// CHECK: i64:64:128
// CHECK: f80:128:256
// CHECK: p0:32:64:128:32
@@ -12,6 +13,7 @@ module attributes {dlti.dl_spec = #dlti.dl_spec<
#dlti.dl_entry<"dlti.endianness", "big">,
#dlti.dl_entry<"dlti.alloca_memory_space", 4 : ui32>,
#dlti.dl_entry<"dlti.stack_alignment", 128 : i32>,
+#dlti.dl_entry<"dlti.mangling_style", "e">,
#dlti.dl_entry<index, 64>,
#dlti.dl_entry<i64, dense<[64,128]> : vector<2xi64>>,
#dlti.dl_entry<f80, dense<[128,256]> : vector<2xi64>>,
diff --git a/mlir/test/lib/Dialect/DLTI/TestDataLayoutQuery.cpp b/mlir/test/lib/Dialect/DLTI/TestDataLayoutQuery.cpp
index 56f309f150ca5..21c635023d591 100644
--- a/mlir/test/lib/Dialect/DLTI/TestDataLayoutQuery.cpp
+++ b/mlir/test/lib/Dialect/DLTI/TestDataLayoutQuery.cpp
@@ -43,6 +43,7 @@ struct TestDataLayoutQuery
uint64_t index = layout.getTypeIndexBitwidth(op.getType()).value_or(0);
Attribute endianness = layout.getEndianness();
Attribute allocaMemorySpace = layout.getAllocaMemorySpace();
+ Attribute manglingStyle = layout.getManglingStyle();
Attribute programMemorySpace = layout.getProgramMemorySpace();
Attribute globalMemorySpace = layout.getGlobalMemorySpace();
uint64_t stackAlignment = layout.getStackAlignment();
@@ -72,6 +73,10 @@ struct TestDataLayoutQuery
allocaMemorySpace == Attribute()
? builder.getUI32IntegerAttr(0)
: allocaMemorySpace),
+ builder.getNamedAttr("mangling_style",
+ manglingStyle == Attribute()
+ ? builder.getStringAttr("")
+ : manglingStyle),
builder.getNamedAttr("program_memory_space",
programMemorySpace == Attribute()
? builder.getUI32IntegerAttr(0)
diff --git a/mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp b/mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp
index db294b8b040e9..8815190daf55a 100644
--- a/mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp
+++ b/mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp
@@ -25,6 +25,7 @@ constexpr static llvm::StringLiteral kAttrName = "dltest.layout";
constexpr static llvm::StringLiteral kEndiannesKeyName = "dltest.endianness";
constexpr static llvm::StringLiteral kAllocaKeyName =
"dltest.alloca_memory_space";
+constexpr static llvm::StringLiteral kManglingStyleKeyName = "dltest.mangling";
constexpr static llvm::StringLiteral kProgramKeyName =
"dltest.program_memory_space";
constexpr static llvm::StringLiteral kGlobalKeyName =
@@ -83,6 +84,9 @@ struct CustomDataLayoutSpec
StringAttr getAllocaMemorySpaceIdentifier(MLIRContext *context) const {
return Builder(context).getStringAttr(kAllocaKeyName);
}
+ StringAttr getManglingStyleIdentifier(MLIRContext *context) const {
+ return Builder(context).getStringAttr(kManglingStyleKeyName);
+ }
StringAttr getProgramMemorySpaceIdentifier(MLIRContext *context) const {
return Builder(context).getStringAttr(kProgramKeyName);
}
More information about the Mlir-commits
mailing list