[MLIR][LLVM] Allow inlining noalias attributes.

[definelicht]

Summary

We can not yet generate new aliasing metadata based on these arguments
because their global nature does not allow parallel inlining, but since
this is not necessary for correctness, we allow inlining functions that
have arguments with the noalias attribute for now.

[gysit]

LGTM!

mlir/lib/Dialect/LLVMIR/IR/LLVMInlining.cpp

if (currentAlignment >= requestedAlignment)
       return argument;
   }
   unsigned targetAlignment = std::max(requestedAlignment, minimumAlignment);
   return handleByValArgumentInit(builder, func.getLoc(), argument, elementType,
                                  dataLayout.getTypeSize(elementType),
                                  targetAlignment);
 }
 
-/// Returns true if the given argument or result attribute is supported by the
-/// inliner, false otherwise.
-static bool isArgOrResAttrSupported(NamedAttribute attr) {
-  if (attr.getName() == LLVM::LLVMDialect::getInAllocaAttrName())
-    return false;
-  if (attr.getName() == LLVM::LLVMDialect::getNoAliasAttrName())
-    return false;
-  return true;
-}
-
 namespace {
 struct LLVMInlinerInterface : public DialectInlinerInterface {
   using DialectInlinerInterface::DialectInlinerInterface;
 
   LLVMInlinerInterface(Dialect *dialect)
       : DialectInlinerInterface(dialect),
         // Cache set of StringAttrs for fast lookup in `isLegalToInline`.
         disallowedFunctionAttrs({
if (!callOp) {
       return false;
     }
     auto funcOp = dyn_cast<LLVM::LLVMFuncOp>(callable);
     if (!funcOp) {
       LLVM_DEBUG(llvm::dbgs()
                  << "Cannot inline: callable is not an LLVM::LLVMFuncOp\n");
       return false;
     }
+    // TODO: Generate aliasing metadata from noalias argument/result attributes.
     if (auto attrs = funcOp.getArgAttrs()) {
       for (DictionaryAttr attrDict : attrs->getAsRange<DictionaryAttr>()) {
-        for (NamedAttribute attr : attrDict) {
-          if (!isArgOrResAttrSupported(attr)) {
-            LLVM_DEBUG(llvm::dbgs() << "Cannot inline " << funcOp.getSymName()
-                                    << ": unhandled argument attribute "
-                                    << attr.getName() << "\n");
-            return false;
-          }
-        }
-      }
-    }
-    if (auto attrs = funcOp.getResAttrs()) {
-      for (DictionaryAttr attrDict : attrs->getAsRange<DictionaryAttr>()) {
-        for (NamedAttribute attr : attrDict) {
-          if (!isArgOrResAttrSupported(attr)) {
-            LLVM_DEBUG(llvm::dbgs() << "Cannot inline " << funcOp.getSymName()
-                                    << ": unhandled return attribute "
-                                    << attr.getName() << "\n");
-            return false;
-          }
-        }
-      }
-    }
+        if (attrDict.contains(LLVM::LLVMDialect::getInAllocaAttrName())) {
+                                  << ": inalloca arguments not supported\n");
     // TODO: Handle exceptions.
     if (funcOp.getPersonality()) {
       LLVM_DEBUG(llvm::dbgs() << "Cannot inline " << funcOp.getSymName()
                               << ": unhandled function personality\n");
       return false;
     }
     if (funcOp.getPassthrough()) {
       // TODO: Used attributes should not be passthrough.

mlir/test/Dialect/LLVMIR/inlining.mlir

llvm.func @test_byval_global() {
   llvm.call @aligned_byval_arg(%unaligned) : (!llvm.ptr) -> ()
   %aligned = llvm.mlir.addressof @aligned_global : !llvm.ptr
   llvm.call @aligned_byval_arg(%aligned) : (!llvm.ptr) -> ()
   llvm.return
 }
 
 // -----
 
-llvm.func @ignored_attrs(%ptr : !llvm.ptr { llvm.inreg, llvm.nocapture, llvm.nofree, llvm.preallocated = i32, llvm.returned, llvm.alignstack = 32 : i64, llvm.writeonly, llvm.noundef, llvm.nonnull }, %x : i32 { llvm.zeroext }) -> (!llvm.ptr { llvm.noundef, llvm.inreg, llvm.nonnull }) {
+llvm.func @ignored_attrs(%ptr : !llvm.ptr { llvm.inreg, llvm.noalias, llvm.nocapture, llvm.nofree, llvm.preallocated = i32, llvm.returned, llvm.alignstack = 32 : i64, llvm.writeonly, llvm.noundef, llvm.nonnull }, %x : i32 { llvm.zeroext }) -> (!llvm.ptr { llvm.noundef, llvm.inreg, llvm.nonnull }) {
   llvm.return %ptr : !llvm.ptr
 }
 
 // CHECK-LABEL: @test_ignored_attrs
 // CHECK-NOT: llvm.call
 // CHECK-NEXT: llvm.return
 llvm.func @test_ignored_attrs(%ptr : !llvm.ptr, %x : i32) {
   llvm.call @ignored_attrs(%ptr, %x) : (!llvm.ptr, i32) -> (!llvm.ptr)
   llvm.return
 }
 
 // -----
 
-llvm.func @disallowed_arg_attr(%ptr : !llvm.ptr { llvm.noalias }) {
+llvm.func @disallowed_arg_attr(%ptr : !llvm.ptr { llvm.inalloca = i64 }) {
   llvm.return
 }
 
 // CHECK-LABEL: @test_disallow_arg_attr
 // CHECK-NEXT: llvm.call
 llvm.func @test_disallow_arg_attr(%ptr : !llvm.ptr) {
   llvm.call @disallowed_arg_attr(%ptr) : (!llvm.ptr) -> ()
   llvm.return
 }
-
-// -----
-
-llvm.func @disallowed_res_attr(%ptr : !llvm.ptr) -> (!llvm.ptr { llvm.noalias }) {
-  llvm.return %ptr : !llvm.ptr
-}
-
-// CHECK-LABEL: @test_disallow_res_attr
-// CHECK-NEXT: llvm.call
-llvm.func @test_disallow_res_attr(%ptr : !llvm.ptr) {
-  llvm.call @disallowed_res_attr(%ptr) : (!llvm.ptr) -> (!llvm.ptr)
-  llvm.return
-}