[mlir][llvm] Use interfaces in the translation to LLVMIR.

[gysit]

Summary

The revision consistently uses the AliasAnalysisOp and AccessGroupOp
interfaces in the translation from MLIR to LLVMIR. It thus drops the
last string based lookups of alias scope and access group attributes.

Depends on D144851

[Dinistro]

LGTM module minor comment.

Note: Can this be considered an NFC? It does change behaviour for operations that do not implement these interfaces but have the attribute attached.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

1010

Are there any remaining usages of LLVMDialect::getAccessGroupsAttrName left after this revision? If not, we should consider dropping it to ensure downstream projects will be aware of this change.

1081

As above

[gysit]

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

1010

I assume now that the interface exist we can indeed remove them true (@frgossen)

[gysit]

Rebase.

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

1010

Are there any remaining usages of LLVMDialect::getAccessGroupsAttrName left after this revision? If not, we should consider dropping it to ensure downstream projects will be aware of this change.

I will do a follow up revision for removing the strings that can land later.

mlir/include/mlir/Target/LLVMIR/ModuleTranslation.h

public:
   /// in these blocks.
   void forgetMapping(Region &region);
 
   /// Returns the LLVM metadata corresponding to a symbol reference to an mlir
   /// LLVM dialect alias scope operation
   llvm::MDNode *getAliasScope(Operation *op, SymbolRefAttr aliasScopeRef) const;
 
   // Sets LLVM metadata for memory operations that are in a parallel loop.
-  void setAccessGroupsMetadata(Operation *op, llvm::Instruction *inst);
+  void setAccessGroupsMetadata(AccessGroupOpInterface op,
+                               llvm::Instruction *inst);
 
   // Sets LLVM metadata for memory operations that have alias scope information.
-  void setAliasScopeMetadata(Operation *op, llvm::Instruction *inst);
+  void setAliasScopeMetadata(AliasAnalysisOpInterface op,
+                             llvm::Instruction *inst);
 
   /// Sets LLVM TBAA metadata for memory operations that have TBAA attributes.
   void setTBAAMetadata(AliasAnalysisOpInterface op, llvm::Instruction *inst);
 
   /// Sets LLVM loop metadata for branch operations that have a loop annotation
   /// attribute.
   void setLoopMetadata(Operation *op, llvm::Instruction *inst);
 

mlir/lib/Target/LLVMIR/LoopAnnotationTranslation.h

public:
   /// and creates corresponding LLVM metadata nodes.
   LogicalResult createAccessGroupMetadata();
 
   /// Returns the LLVM metadata corresponding to a symbol reference to an mlir
   /// LLVM dialect access group operation.
   llvm::MDNode *getAccessGroup(Operation *op,
                                SymbolRefAttr accessGroupRef) const;
 
-  /// Returns the LLVM metadata corresponding to a list of symbol reference to
-  /// an mlir LLVM dialect access group operation. Returns nullptr if
-  /// `accessGroupRefs` is null or empty.
-  llvm::MDNode *getAccessGroups(Operation *op, ArrayAttr accessGroupRefs) const;
+  /// Returns the LLVM metadata corresponding to the access group operations
+  /// referenced by the AccessGroupOpInterface or null if there are none.
+  llvm::MDNode *getAccessGroups(AccessGroupOpInterface op) const;
 
 private:
   /// Returns the LLVM metadata corresponding to a llvm loop metadata attribute.
   llvm::MDNode *lookupLoopMetadata(Attribute options) const {
     return loopMetadataMapping.lookup(options);
   }
 
   void mapLoopMetadata(Attribute options, llvm::MDNode *metadata) {

mlir/lib/Target/LLVMIR/LoopAnnotationTranslation.cpp

LoopAnnotationTranslation::getAccessGroup(Operation *op,
   auto metadataOp = SymbolTable::lookupNearestSymbolFrom<LLVM::MetadataOp>(
       op->getParentOp(), metadataName);
   auto *accessGroupOp =
       SymbolTable::lookupNearestSymbolFrom(metadataOp, accessGroupName);
   return accessGroupMetadataMapping.lookup(accessGroupOp);
 }
 
 llvm::MDNode *
-LoopAnnotationTranslation::getAccessGroups(Operation *op,
-                                           ArrayAttr accessGroupRefs) const {
+LoopAnnotationTranslation::getAccessGroups(AccessGroupOpInterface op) const {
+  ArrayAttr accessGroupRefs = op.getAccessGroupsOrNull();
   if (!accessGroupRefs || accessGroupRefs.empty())
     return nullptr;
 
   SmallVector<llvm::Metadata *> groupMDs;
   for (SymbolRefAttr groupRef : accessGroupRefs.getAsRange<SymbolRefAttr>())
     groupMDs.push_back(getAccessGroup(op, groupRef));
   if (groupMDs.size() == 1)
     return llvm::cast<llvm::MDNode>(groupMDs.front());
   return llvm::MDNode::get(llvmModule.getContext(), groupMDs);
 }

mlir/lib/Target/LLVMIR/ModuleTranslation.cpp

LogicalResult ModuleTranslation::convertFunctions() {
 
   return success();
 }
 
 LogicalResult ModuleTranslation::createAccessGroupMetadata() {
   return loopAnnotationTranslation->createAccessGroupMetadata();
 }
 
-void ModuleTranslation::setAccessGroupsMetadata(Operation *op,
+void ModuleTranslation::setAccessGroupsMetadata(AccessGroupOpInterface op,
                                                 llvm::Instruction *inst) {
-  auto populateGroupsMetadata = [&](ArrayAttr groupRefs) {
-    if (llvm::MDNode *node =
-            loopAnnotationTranslation->getAccessGroups(op, groupRefs))
-      inst->setMetadata(llvm::LLVMContext::MD_access_group, node);
-  };
-
-  auto groupRefs =
-      op->getAttrOfType<ArrayAttr>(LLVMDialect::getAccessGroupsAttrName());
-  populateGroupsMetadata(groupRefs);
+  if (llvm::MDNode *node = loopAnnotationTranslation->getAccessGroups(op))
 }
 
 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();
ModuleTranslation::getAliasScope(Operation *op,
   StringAttr scopeName = aliasScopeRef.getLeafReference();
   auto metadataOp = SymbolTable::lookupNearestSymbolFrom<LLVM::MetadataOp>(
       op->getParentOp(), metadataName);
   Operation *aliasScopeOp =
       SymbolTable::lookupNearestSymbolFrom(metadataOp, scopeName);
   return aliasScopeMetadataMapping.lookup(aliasScopeOp);
 }
 
-void ModuleTranslation::setAliasScopeMetadata(Operation *op,
+void ModuleTranslation::setAliasScopeMetadata(AliasAnalysisOpInterface op,
                                               llvm::Instruction *inst) {
   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>())
       scopeMDs.push_back(getAliasScope(op, scopeRef));
     llvm::MDNode *node = llvm::MDNode::get(module->getContext(), scopeMDs);
     inst->setMetadata(kind, node);
   };
 
-  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);
+  populateScopeMetadata(op.getAliasScopesOrNull(),
+                        llvm::LLVMContext::MD_alias_scope);
+  populateScopeMetadata(op.getNoAliasScopesOrNull(),
+                        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);