[mlir][llvm] Reintroduce string based attribute setting.

[gysit]

Summary

Reintroduce string based attribute setting in the
translation from LLVM dialect to LLVM IR. The TypeSwitch
based implementation introduced in
https://reviews.llvm.org/D143654 does not work for
intrinsics that set the requiresAccessGroup or
requiresAliasScope flag.

[gysit]

@hgreving this should fix the issue for intrinsics that use the requiresAccessGroup or requiresAliasScope flags. Let me know if this is not needed urgently, then I would suggest to work on a interface solution instead.

[hgreving]

I wonder if we should add a test for this. Thanks a lot for the fix here.

[gysit]

We plan to add alias scope / access group attributes to the memcpy intrinsics soon. That will be good opportunity to add a test. I hope it is ok if I land tomorrow morning European time?

[hgreving]

In D143936#4124005, @gysit wrote:

We plan to add alias scope / access group attributes to the memcpy intrinsics soon. That will be good opportunity to add a test. I hope it is ok if I land tomorrow morning European time?

Yes, thanks.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

 #include "mlir/Dialect/OpenMP/OpenMPDialect.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/BuiltinTypes.h"
 #include "mlir/IR/RegionGraphTraits.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Target/LLVMIR/LLVMTranslationInterface.h"
 #include "mlir/Target/LLVMIR/TypeToLLVM.h"
-#include "llvm/ADT/TypeSwitch.h"
 
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Constants.h"
metadatas.walk([&](LLVM::AccessGroupMetadataOp op) {
       accessGroupMetadataMapping.insert({op, accessGroup});
     });
   });
   return success();
 }
 
 void ModuleTranslation::setAccessGroupsMetadata(Operation *op,
                                                 llvm::Instruction *inst) {
-  auto populateGroupsMetadata = [&](std::optional<ArrayAttr> groupRefs) {
-    if (!groupRefs || groupRefs->empty())
+  auto populateGroupsMetadata = [&](ArrayAttr groupRefs) {
+    if (!groupRefs || groupRefs.empty())
       return;
 
     llvm::Module *module = inst->getModule();
     SmallVector<llvm::Metadata *> groupMDs;
-    for (SymbolRefAttr groupRef : groupRefs->getAsRange<SymbolRefAttr>())
+    for (SymbolRefAttr groupRef : groupRefs.getAsRange<SymbolRefAttr>())
       groupMDs.push_back(getAccessGroup(op, groupRef));
 
     llvm::MDNode *node = nullptr;
     if (groupMDs.size() == 1)
       node = llvm::cast<llvm::MDNode>(groupMDs.front());
     else if (groupMDs.size() >= 2)
       node = llvm::MDNode::get(module->getContext(), groupMDs);
 
     inst->setMetadata(llvm::LLVMContext::MD_access_group, node);
   };
 
-  llvm::TypeSwitch<Operation *>(op)
-      .Case<LoadOp, StoreOp>(
-          [&](auto memOp) { populateGroupsMetadata(memOp.getAccessGroups()); })
-      .Default([](auto) { llvm_unreachable("expected LoadOp or StoreOp"); });
+  auto groupRefs =
+      op->getAttrOfType<ArrayAttr>(LLVMDialect::getAccessGroupsAttrName());
+  populateGroupsMetadata(groupRefs);
 }
 
 LogicalResult ModuleTranslation::createAliasScopeMetadata() {
   mlirModule->walk([&](LLVM::MetadataOp metadatas) {
     // Create the domains first, so they can be reference below in the scopes.
     DenseMap<Operation *, llvm::MDNode *> aliasScopeDomainMetadataMapping;
     metadatas.walk([&](LLVM::AliasScopeDomainMetadataOp op) {
       llvm::LLVMContext &ctx = llvmModule->getContext();
auto metadataOp = SymbolTable::lookupNearestSymbolFrom<LLVM::MetadataOp>(
       op->getParentOp(), metadataName);
   Operation *aliasScopeOp =
       SymbolTable::lookupNearestSymbolFrom(metadataOp, scopeName);
   return aliasScopeMetadataMapping.lookup(aliasScopeOp);
 }
 
 void ModuleTranslation::setAliasScopeMetadata(Operation *op,
                                               llvm::Instruction *inst) {
-  auto populateScopeMetadata = [&](std::optional<ArrayAttr> scopeRefs,
-                                   unsigned kind) {
-    if (!scopeRefs || scopeRefs->empty())
+  auto populateScopeMetadata = [&](ArrayAttr scopeRefs, unsigned kind) {
+    if (!scopeRefs || scopeRefs.empty())
       return;
     llvm::Module *module = inst->getModule();
     SmallVector<llvm::Metadata *> scopeMDs;
-    for (SymbolRefAttr scopeRef : scopeRefs->getAsRange<SymbolRefAttr>())
+    for (SymbolRefAttr scopeRef : scopeRefs.getAsRange<SymbolRefAttr>())
       scopeMDs.push_back(getAliasScope(op, scopeRef));
     llvm::MDNode *node = llvm::MDNode::get(module->getContext(), scopeMDs);
     inst->setMetadata(kind, node);
   };
 
-  llvm::TypeSwitch<Operation *>(op)
-      .Case<LoadOp, StoreOp>([&](auto memOp) {
-        populateScopeMetadata(memOp.getAliasScopes(),
-                              llvm::LLVMContext::MD_alias_scope);
-        populateScopeMetadata(memOp.getNoaliasScopes(),
-                              llvm::LLVMContext::MD_noalias);
-      })
-      .Default([](auto) { llvm_unreachable("expected LoadOp or StoreOp"); });
+  auto aliasScopeRefs =
+      op->getAttrOfType<ArrayAttr>(LLVMDialect::getAliasScopesAttrName());
+  populateScopeMetadata(aliasScopeRefs, llvm::LLVMContext::MD_alias_scope);
+
+  auto noaliasScopeRefs =
+      op->getAttrOfType<ArrayAttr>(LLVMDialect::getNoAliasScopesAttrName());
+  populateScopeMetadata(noaliasScopeRefs, llvm::LLVMContext::MD_noalias);
 }
 
 llvm::MDNode *ModuleTranslation::getTBAANode(Operation *op,
                                              SymbolRefAttr tagRef) const {
   StringAttr metadataName = tagRef.getRootReference();
   StringAttr tagName = tagRef.getLeafReference();
   auto metadataOp = SymbolTable::lookupNearestSymbolFrom<LLVM::MetadataOp>(
       op->getParentOp(), metadataName);