[Mlir-commits] [mlir] [MLIR][DLTI] Add mangling style (PR #125875)
llvmlistbot at llvm.org
llvmlistbot at llvm.org
Wed Feb 5 07:57:09 PST 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-mlir
Author: Guojin (ghehg)
<details>
<summary>Changes</summary>
Add mangling style as a spec entry to datalayout, and implemented importing and exporting LLVM IR to MLIR (LLVM dialect).
Its represented as string as the scope of this PR is to preserve info from LLVM IR, so client in MLIR still need to map deduce the meaning of the string, like "e" means ELF, "o" for Mach-O, etc.
---
Full diff: https://github.com/llvm/llvm-project/pull/125875.diff
14 Files Affected:
- (modified) mlir/include/mlir/Dialect/DLTI/DLTIAttrs.td (+3)
- (modified) mlir/include/mlir/Dialect/DLTI/DLTIBase.td (+3)
- (modified) mlir/include/mlir/Interfaces/DataLayoutInterfaces.h (+9)
- (modified) mlir/include/mlir/Interfaces/DataLayoutInterfaces.td (+18)
- (modified) mlir/lib/Dialect/DLTI/DLTI.cpp (+8-1)
- (modified) mlir/lib/Interfaces/DataLayoutInterfaces.cpp (+27)
- (modified) mlir/lib/Target/LLVMIR/DataLayoutImporter.cpp (+22)
- (modified) mlir/lib/Target/LLVMIR/DataLayoutImporter.h (+4)
- (modified) mlir/lib/Target/LLVMIR/ModuleTranslation.cpp (+5)
- (modified) mlir/test/Target/LLVMIR/Import/data-layout.ll (+1)
- (modified) mlir/test/Target/LLVMIR/Import/import-failure.ll (+5)
- (modified) mlir/test/Target/LLVMIR/data-layout.mlir (+2)
- (modified) mlir/test/lib/Dialect/DLTI/TestDataLayoutQuery.cpp (+5)
- (modified) mlir/unittests/Interfaces/DataLayoutInterfacesTest.cpp (+4)
``````````diff
diff --git a/mlir/include/mlir/Dialect/DLTI/DLTIAttrs.td b/mlir/include/mlir/Dialect/DLTI/DLTIAttrs.td
index d54b3191eed7e6..9bede41a83374e 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 f84149c43e0fcd..b1f54c608e03ee 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 7a7b659724f860..33fadf842cef1b 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 0d09b92928fe33..8626fb0709a240 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 2510e774f2b2aa..fcb76eb34d0b7b 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(
@@ -589,7 +595,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 049d7f123cec8f..93f91bdc451f98 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 35fdbc0be22c31..b79ee902ff29f6 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 59b60acd24be20..a66402065cb105 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 4367100e3aca68..7f4b9fd3e0e3ef 100644
--- a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp
+++ b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp
@@ -198,6 +198,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 c397053585e3c9..b21043718e19e5 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 d929a592847622..80656493a99eb7 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 881d6727e2a17a..c8aa7ed14b73fe 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 56f309f150ca5d..21c635023d5915 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 db294b8b040e9d..8815190daf55a2 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);
}
``````````
</details>
https://github.com/llvm/llvm-project/pull/125875
More information about the Mlir-commits
mailing list