add test

Author: fabianmcg

mlir/unittests/Target/LLVM/SerializeToLLVMBitcode.cpp

@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "mlir/Dialect/GPU/IR/GPUDialect.h"
+#include "mlir/IR/BuiltinDialect.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/Parser/Parser.h"
@@ -30,24 +32,46 @@ using namespace mlir;
 #define SKIP_WITHOUT_NATIVE(x) x
 #endif
 
+namespace {
+// Dummy interface for testing.
+class TargetAttrImpl
+    : public gpu::TargetAttrInterface::FallbackModel<TargetAttrImpl> {
+public:
+  std::optional<SmallVector<char, 0>>
+  serializeToObject(Attribute attribute, Operation *module,
+                    const gpu::TargetOptions &options) const;
+
+  Attribute createObject(Attribute attribute, Operation *module,
+                         const SmallVector<char, 0> &object,
+                         const gpu::TargetOptions &options) const;
+};
+} // namespace
+
 class MLIRTargetLLVM : public ::testing::Test {
 protected:
   void SetUp() override {
     llvm::InitializeNativeTarget();
     llvm::InitializeNativeTargetAsmPrinter();
+    registry.addExtension(+[](MLIRContext *ctx, BuiltinDialect *dialect) {
+      IntegerAttr::attachInterface<TargetAttrImpl>(*ctx);
+    });
+    registerBuiltinDialectTranslation(registry);
+    registerLLVMDialectTranslation(registry);
+    registry.insert<gpu::GPUDialect>();
   }
-};
 
-TEST_F(MLIRTargetLLVM, SKIP_WITHOUT_NATIVE(SerializeToLLVMBitcode)) {
+  // Dialect registry.
+  DialectRegistry registry;
+
+  // MLIR module used for the tests.
   std::string moduleStr = R"mlir(
   llvm.func @foo(%arg0 : i32) {
     llvm.return
   }
   )mlir";
+};
 
-  DialectRegistry registry;
-  registerBuiltinDialectTranslation(registry);
-  registerLLVMDialectTranslation(registry);
+TEST_F(MLIRTargetLLVM, SKIP_WITHOUT_NATIVE(SerializeToLLVMBitcode)) {
   MLIRContext context(registry);
 
   OwningOpRef<ModuleOp> module =
@@ -74,3 +98,52 @@ TEST_F(MLIRTargetLLVM, SKIP_WITHOUT_NATIVE(SerializeToLLVMBitcode)) {
   // Check that it has a function named `foo`.
   ASSERT_TRUE((*llvmModule)->getFunction("foo") != nullptr);
 }
+
+std::optional<SmallVector<char, 0>>
+TargetAttrImpl::serializeToObject(Attribute attribute, Operation *module,
+                                  const gpu::TargetOptions &options) const {
+  module->setAttr("serialize_attr", UnitAttr::get(module->getContext()));
+  std::string targetTriple = llvm::sys::getProcessTriple();
+  LLVM::ModuleToObject serializer(*module, targetTriple, "", "");
+  return serializer.run();
+}
+
+Attribute
+TargetAttrImpl::createObject(Attribute attribute, Operation *module,
+                             const SmallVector<char, 0> &object,
+                             const gpu::TargetOptions &options) const {
+  return gpu::ObjectAttr::get(
+      module->getContext(), attribute, gpu::CompilationTarget::Offload,
+      StringAttr::get(module->getContext(),
+                      StringRef(object.data(), object.size())),
+      module->getAttrDictionary());
+}
+
+TEST_F(MLIRTargetLLVM, SKIP_WITHOUT_NATIVE(TargetAttrAPI)) {
+  MLIRContext context(registry);
+  context.loadAllAvailableDialects();
+
+  OwningOpRef<ModuleOp> module =
+      parseSourceString<ModuleOp>(moduleStr, &context);
+  ASSERT_TRUE(!!module);
+  Builder builder(&context);
+  IntegerAttr target = builder.getI32IntegerAttr(0);
+  auto targetAttr = dyn_cast<gpu::TargetAttrInterface>(target);
+  // Check the attribute holds the interface.
+  ASSERT_TRUE(!!targetAttr);
+  gpu::TargetOptions opts;
+  std::optional<SmallVector<char, 0>> serializedBinary =
+      targetAttr.serializeToObject(*module, opts);
+  // Check the serialized string.
+  ASSERT_TRUE(!!serializedBinary);
+  ASSERT_TRUE(!serializedBinary->empty());
+  // Create the object attribute.
+  auto object = cast<gpu::ObjectAttr>(
+      targetAttr.createObject(*module, *serializedBinary, opts));
+  // Check the object has properties.
+  DictionaryAttr properties = object.getProperties();
+  ASSERT_TRUE(!!properties);
+  // Check that it contains the attribute added to the module in
+  // `serializeToObject`.
+  ASSERT_TRUE(properties.contains("serialize_attr"));
+}