[mlir][LLVM] Convert `noalias` parameters into alias scopes during inlining

[zero9178]

Summary

Currently, inlining a function with a noalias parameter leads to a large loss of optimization potential as the noalias parameter, an important hint for alias analysis, is lost completely.

This patch fixes this with the same approach as LLVM by annotating all users of the noalias parameter with appropriate alias and noalias scope lists.
The implementation done here is not as sophisticated as LLVMs, which has more infrastructure related to escaping and captured pointers, but should work in the majority of important cases.
Any deficiency can be addressed in future patches.

Related LLVM code: https://github.com/llvm/llvm-project/blob/27ade4b554774187d2c0afcf64cd16fa6d5f619d/llvm/lib/Transforms/Utils/InlineFunction.cpp#L1090

[gysit]

Very nice!

LGTM modulo minor comments.

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

216

I think it is fine to not support typed pointers at this stage (AFAIK there should be no bitcasts for opaque pointers).

331

Should we use the function name as a descriptor?

346–360

Would it make sense to add this functionality to the AliasAnalysisOpInterface?

415

424–425

nit: tried to clarify the comment a bit. Feel free to use your own formulation if I got it wrong :)

mlir/test/Dialect/LLVMIR/inlining-alias-scopes.mlir

198–199

ultra nit: can you drop the double newlines here and below.

[definelicht]

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

205–208

232–235

236

Why not just return the resultSet?

236–237

The documentation of these two functions makes them sound like they do pretty much exactly the same 🙂 Try renaming and extending the docstring to clarify their relationship

243

What happens if the maximum number of lookups is exceeded? Consider adding a test where this collides with another underlying object.

348–360

Maybe an llvm_unreachable default case?

771–781

Some suggestions for clarification!

[zero9178]

Address review comments:

• Extend AliasAnalysisOpInterface to return pointer operands
• Clarify and update comments
• Other codestyle issues

PTAL @gysit @definelicht

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

243

What would happen is that the current pointer value would be returned and the code below would identify it as an unknown object where it does not know it is based on any noalias parameter or not and therefore abort putting any scope on the operation.

I ended up removing the parameter though. I originally took it from LLVM but in MLIR it has so far not been convention to put such bounds on functions and writing tests for it, I realized that its hard to write a test in a way that can't just be canonicalized easily in the future (making the bound somewhat a bad workaround for a missing canonicalization IMO).

[zero9178]

rebase

[gysit]

Can you maybe add a test case that exercises the memory intrinsics?

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

20

nit: Is the TypeSwitch still needed?

[zero9178]

• Add tests exercising all operations with alias scopes
• Fix bug discovered through the new test which mistakenly created empty scope lists

[zero9178]

remove redundant typeswitch include

[definelicht]

LGTM with some grammar fixes 🤓

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

205–207

Instead of "best effort" and "best result", write concretely what the semantics actually are (trace back until the end or an op it cannot resolve).

226–230

I would remove the "best effort" sentence altogether, since it doesn't really add much (the first word is already "attempts"). If you want you can add a sentence on concretely what happens if it doesn't resolve a path.

771–781

[gysit]

Looks even more LGTM!

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

 //
 //===----------------------------------------------------------------------===//
 
 #include "LLVMInlining.h"
 #include "mlir/Dialect/LLVMIR/LLVMDialect.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Interfaces/DataLayoutInterfaces.h"
 #include "mlir/Transforms/InliningUtils.h"
+#include "llvm/ADT/ScopeExit.h"
+#include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 
 #define DEBUG_TYPE "llvm-inliner"
 
 using namespace mlir;
 
 /// Check whether the given alloca is an input to a lifetime intrinsic,
 /// optionally passing through one or more casts on the way. This is not
if (!rhs)
     return lhs;
 
   SmallVector<Attribute> result;
   llvm::append_range(result, lhs);
   llvm::append_range(result, rhs);
   return ArrayAttr::get(lhs.getContext(), result);
 }
 
+/// Attempts to return the underlying pointer value that `pointerValue` is based
+/// on. This is done on a best-effort basis and returns the best-result so far
+/// if unable to continue or if more than `maxLookup` attempts have been
+/// performed.
+static Value getUnderlyingObject(Value pointerValue, unsigned maxLookup = 6) {
+  for (; maxLookup > 0; maxLookup--) {
+    if (auto gepOp = pointerValue.getDefiningOp<LLVM::GEPOp>()) {
+      pointerValue = gepOp.getBase();
+      continue;
+    }
+
+    if (auto bitCast = pointerValue.getDefiningOp<LLVM::BitcastOp>()) {
+      pointerValue = bitCast.getOperand();
+      continue;
+    }
+
+    if (auto addrCast = pointerValue.getDefiningOp<LLVM::AddrSpaceCastOp>()) {
+      pointerValue = addrCast.getOperand();
+      continue;
+    }
+
+    break;
+  }
+
+  return pointerValue;
+}
+
+/// Attempts to collect all underlying pointer values that `pointerValue` is
+/// based on and inserts them into `resultSet`. Finding the underlying pointer
+/// object is done on best-effort basis and will contain the best-result found
+/// so far.
+static void collectUnderlyingObjects(Value pointerValue,
+                                     SmallPtrSetImpl<Value> &resultSet) {
+  SmallVector<Value> workList{pointerValue};
+  // Avoid dataflow loops.
+  SmallPtrSet<Value, 4> seen;
+  do {
+    Value current = workList.pop_back_val();
+    current = getUnderlyingObject(current);
+
+    if (!seen.insert(current).second)
+      continue;
+
+    if (auto selectOp = current.getDefiningOp<LLVM::SelectOp>()) {
+      workList.push_back(selectOp.getTrueValue());
+      workList.push_back(selectOp.getFalseValue());
+      continue;
+    }
+
+    if (auto blockArg = dyn_cast<BlockArgument>(current)) {
+      Block *parentBlock = blockArg.getParentBlock();
+
+      // Attempt to find all block argument operands for every predecessor.
+      // If any operand to the block argument wasn't found in a predecessor,
+      // conservatively add the block argument to the result set.
+      SmallVector<Value> operands;
+      bool anyUnknown = false;
+      for (auto iter = parentBlock->pred_begin();
+           iter != parentBlock->pred_end(); iter++) {
+        auto branch = dyn_cast<BranchOpInterface>((*iter)->getTerminator());
+        if (!branch) {
+          resultSet.insert(blockArg);
+          anyUnknown = true;
+          break;
+        }
+
+        Value operand = branch.getSuccessorOperands(
+            iter.getSuccessorIndex())[blockArg.getArgNumber()];
+        if (!operand) {
+          resultSet.insert(blockArg);
+          anyUnknown = true;
+          break;
+        }
+
+        operands.push_back(operand);
+      }
+
+      if (!anyUnknown)
+        llvm::append_range(workList, operands);
+
+      continue;
+    }
+
+    resultSet.insert(current);
+  } while (!workList.empty());
+}
+
+/// Creates a new AliasScopeAttr for every noalias parameter and attaches it to
+/// the appropriate inlined memory operations in an attempt to preserve the
+/// original semantics of the parameter attribute.
+static void createNewAliasScopesFromNoAliasParameter(
+    Operation *call, iterator_range<Region::iterator> inlinedBlocks) {
+
+  // First collect all noalias parameters. These have been specially marked by
+  // the `handleArgument` implementation by using the `ssa.copy` intrinsic and
+  // attaching a `noalias` attribute to it.
+  // These are only meant to be temporary and should therefore be deleted after
+  // we're done using them here.
+  SetVector<LLVM::SSACopyOp> noAliasParams;
+  for (Value argument : cast<LLVM::CallOp>(call).getArgOperands()) {
+    for (Operation *user : argument.getUsers()) {
+      auto ssaCopy = llvm::dyn_cast<LLVM::SSACopyOp>(user);
+      if (!ssaCopy)
+        continue;
+      if (!ssaCopy->hasAttr(LLVM::LLVMDialect::getNoAliasAttrName()))
+        continue;
+
+      noAliasParams.insert(ssaCopy);
+    }
+  }
+
+  // If there were none, we have nothing to do here.
+  if (noAliasParams.empty())
+    return;
+
+  // Scope exit block to make it impossible to forget to get rid of the
+  // intrinsics.
+  auto exit = llvm::make_scope_exit([&] {
+    for (LLVM::SSACopyOp ssaCopyOp : noAliasParams) {
+      ssaCopyOp.replaceAllUsesWith(ssaCopyOp.getOperand());
+      ssaCopyOp->erase();
+    }
+  });
+
+  // Create a new domain for this specific inlining and a new scope for every
+  // noalias parameter.
+  auto functionDomain = LLVM::AliasScopeDomainAttr::get(call->getContext());
+  DenseMap<Value, LLVM::AliasScopeAttr> pointerScopes;
+  for (LLVM::SSACopyOp copyOp : noAliasParams) {
+    auto scope = LLVM::AliasScopeAttr::get(functionDomain);
+    pointerScopes[copyOp] = scope;
+
+    OpBuilder(call).create<LLVM::NoAliasScopeDeclOp>(call->getLoc(), scope);
+  }
+
+  // Go through every instruction and attempt to find which noalias parameters
+  // it is definitely based on and definitely not based on.
+  for (Block &inlinedBlock : inlinedBlocks) {
+    for (auto aliasInterface :
+         inlinedBlock.getOps<LLVM::AliasAnalysisOpInterface>()) {
+
+      // Collect the pointer arguments affected by the alias scopes.
+      SmallVector<Value> pointerArgs;
+      llvm::TypeSwitch<Operation *>(aliasInterface.getOperation())
+          .Case<LLVM::LoadOp, LLVM::StoreOp>([&](auto loadStoreOp) {
+            pointerArgs.push_back(loadStoreOp.getAddr());
+          })
+          .Case<LLVM::AtomicRMWOp, LLVM::AtomicCmpXchgOp>(
+              [&](auto atomicOp) { pointerArgs.push_back(atomicOp.getPtr()); })
+          .Case([&](LLVM::CallOp callOp) {
+            llvm::append_range(
+                pointerArgs,
+                llvm::make_filter_range(callOp.getArgOperands(), [](Value arg) {
+                  return isa<LLVM::LLVMPointerType>(arg.getType());
+                }));
+          });
+
+      // Find the set of underlying pointers that this pointer is based on.
+      SmallPtrSet<Value, 4> basedOnPointers;
+      for (Value pointer : pointerArgs)
+        collectUnderlyingObjects(pointer, basedOnPointers);
+
+      bool aliasesOtherKnownObject = false;
+      // Go through the based on pointers and check that they are either:
+      // * Constants that can be ignored (undef, poison, null pointer).
+      // * Based on a noalias parameter.
+      // * Other pointers that we know can't alias with our noalias parameter.
+      //
+      // Any other value might be a pointer based on any noalias parameter that
+      // hasn't been identified. In that case conservatively don't add any
+      // scopes to this operation indicating either aliasing or not aliasing
+      // with any parameter.
+      if (llvm::any_of(basedOnPointers, [&](Value object) {
+            if (matchPattern(object, m_Constant()))
+              return false;
+
+            if (noAliasParams.contains(object.getDefiningOp<LLVM::SSACopyOp>()))
+              return false;
+
+            // TODO: This should include other arguments from the inlined
+            //       callable.
+            if (isa_and_nonnull<LLVM::AllocaOp, LLVM::AddressOfOp>(
+                    object.getDefiningOp())) {
+              aliasesOtherKnownObject = true;
+              return false;
+            }
+            return true;
+          }))
+        continue;
+
+      // Add all noalias parameter scopes to the noalias scope list that we are
+      // not based on.
+      SmallVector<Attribute> noAliasScopes;
+      for (LLVM::SSACopyOp noAlias : noAliasParams) {
+        if (basedOnPointers.contains(noAlias))
+          continue;
+
+        noAliasScopes.push_back(pointerScopes[noAlias]);
+      }
+
+      aliasInterface.setNoAliasScopes(
+          concatArrayAttr(aliasInterface.getNoAliasScopesOrNull(),
+                          ArrayAttr::get(call->getContext(), noAliasScopes)));
+
+      // Don't add alias scopes to call operations or operations that might
+      // operate on pointers not based on any noalias parameter.
+      // Since we add all scopes to an operation's noalias list that it
+      // definitely doesn't alias, we mustn't do the same for the alias.scope
+      // list if unknown objects are involved.
+      //
+      // Consider following case:
+      // %0 = llvm.alloca
+      // %1 = select %magic, %0, %noalias_param
+      // store 5, %1  (1) noalias=[scope(...)]
+      // ...
+      // store 3, %0  (2) noalias=[scope(noalias_param), scope(...)]
+      //
+      // We can add the scopes of any noalias parameters that aren't
+      // noalias_param's scope to (1) and add all of them to (2). We mustn't add
+      // the scope of noalias_param to the alias.scope list of (1) however as
+      // that would mean (2) no longer affects (1).
+      //
+      // In conclusion, only add scopes to the alias.scope list if all pointers
+      // have a corresponding scope.
+      // Call operations are included in this list since we do not know whether
+      // the callee accesses any memory besides the ones passed as its
+      // arguments.
+      if (aliasesOtherKnownObject ||
+          isa<LLVM::CallOp>(aliasInterface.getOperation()))
+        continue;
+
+      SmallVector<Attribute> aliasScopes;
+      for (LLVM::SSACopyOp noAlias : noAliasParams)
+        if (basedOnPointers.contains(noAlias))
+          aliasScopes.push_back(pointerScopes[noAlias]);
+
+      aliasInterface.setAliasScopes(
+          concatArrayAttr(aliasInterface.getAliasScopesOrNull(),
+                          ArrayAttr::get(call->getContext(), aliasScopes)));
+    }
+  }
+}
+
 /// Appends any alias scopes of the call operation to any inlined memory
 /// operation.
 static void
 appendCallOpAliasScopes(Operation *call,
                         iterator_range<Region::iterator> inlinedBlocks) {
   auto callAliasInterface = dyn_cast<LLVM::AliasAnalysisOpInterface>(call);
   if (!callAliasInterface)
     return;
for (Block &block : inlinedBlocks) {
     }
   }
 }
 
 /// Handles all interactions with alias scopes during inlining.
 static void handleAliasScopes(Operation *call,
                               iterator_range<Region::iterator> inlinedBlocks) {
   deepCloneAliasScopes(inlinedBlocks);
+  createNewAliasScopesFromNoAliasParameter(call, inlinedBlocks);
   appendCallOpAliasScopes(call, inlinedBlocks);
 }
 
 /// If `requestedAlignment` is higher than the alignment specified on `alloca`,
 /// realigns `alloca` if this does not exceed the natural stack alignment.
 /// Returns the post-alignment of `alloca`, whether it was realigned or not.
 static unsigned tryToEnforceAllocaAlignment(LLVM::AllocaOp alloca,
                                             unsigned requestedAlignment,
if (std::optional<NamedAttribute> attr =
               argumentAttrs.getNamed(LLVM::LLVMDialect::getAlignAttrName())) {
         requestedAlignment = cast<IntegerAttr>(alignAttr->getValue())
                                  .getValue()
                                  .getLimitedValue();
       }
       return handleByValArgument(builder, callable, argument, elementType,
                                  requestedAlignment);
     }
+    if (std::optional<NamedAttribute> attr =
+            argumentAttrs.getNamed(LLVM::LLVMDialect::getNoAliasAttrName())) {
+      if (argument.use_empty())
+        return argument;
+
+      // The code here is essentially a workaround for deficiencies in the
+      // inliner interface. The issue boils down to the fact that we need to
+      // transformations on the inlined operations based on the argument
+      // attributes of the parameters. This method runs prior to actual inlining
+      // while 'processInlinedCallBlocks' does not have access to function
+      // arguments. Additionally, it is required to distinguish from what
+      // parameter an SSA value originally came from. Until this is changed,
+      // create an ssa.copy intrinsic with the noalias attribute that can easily
+      // be found and is extremely unlikely to exist in the code prior to
+      // inlining as a sort of marker for a value stemming from a noalias
+      // parameter.
+      // TODO: Fix this by refactoring the inliner interface.
+      auto copyOp = builder.create<LLVM::SSACopyOp>(call->getLoc(), argument);
+      copyOp->setDiscardableAttr(
+          builder.getStringAttr(LLVM::LLVMDialect::getNoAliasAttrName()),
+          builder.getUnitAttr());
+      return copyOp;
+    }
     return argument;
   }
 
   void processInlinedCallBlocks(
       Operation *call,
       iterator_range<Region::iterator> inlinedBlocks) const override {
     handleInlinedAllocas(call, inlinedBlocks);
     handleAliasScopes(call, inlinedBlocks);

mlir/test/Dialect/LLVMIR/inlining-alias-scopes.mlir

 llvm.func @caller(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr) {
   %0 = llvm.load %arg2 {alias_scopes = [#alias_scope2], alignment = 8 : i64} : !llvm.ptr -> !llvm.ptr
   llvm.call @callee_with_metadata(%arg0, %arg1, %0) {noalias_scopes = [#alias_scope2]} : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
   llvm.call @callee_with_metadata(%arg1, %arg1, %arg0) {alias_scopes = [#alias_scope2]} : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
   llvm.call @callee_without_metadata(%arg0, %arg1, %0) {noalias_scopes = [#alias_scope2]} : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
   llvm.call @callee_without_metadata(%arg1, %arg1, %arg0) {alias_scopes = [#alias_scope2]} : (!llvm.ptr, !llvm.ptr, !llvm.ptr) -> ()
   llvm.return
 }
+
+
+// -----
+
+// CHECK-DAG: #[[DOMAIN:.*]] = #llvm.alias_scope_domain<{{.*}}>
+// CHECK-DAG: #[[$ARG0_SCOPE:.*]] = #llvm.alias_scope<id = {{.*}}, domain = #[[DOMAIN]]{{(,.*)?}}>
+// CHECK-DAG: #[[$ARG1_SCOPE:.*]] = #llvm.alias_scope<id = {{.*}}, domain = #[[DOMAIN]]{{(,.*)?}}>
+
+llvm.func @foo(%arg0: !llvm.ptr {llvm.noalias}, %arg1: !llvm.ptr {llvm.noalias}) {
+  %0 = llvm.mlir.constant(5 : i64) : i64
+  %1 = llvm.load %arg1 {alignment = 4 : i64} : !llvm.ptr -> f32
+  %2 = llvm.getelementptr inbounds %arg0[%0] : (!llvm.ptr, i64) -> !llvm.ptr, f32
+  llvm.store %1, %2 {alignment = 4 : i64} : f32, !llvm.ptr
+  llvm.return
+}
+
+// CHECK-LABEL: llvm.func @bar
+// CHECK: llvm.load
+// CHECK-SAME: alias_scopes = [#[[$ARG1_SCOPE]]]
+// CHECK-SAME: noalias_scopes = [#[[$ARG0_SCOPE]]]
+// CHECK: llvm.store
+// CHECK-SAME: alias_scopes = [#[[$ARG0_SCOPE]]]
+// CHECK-SAME: noalias_scopes = [#[[$ARG1_SCOPE]]]
+llvm.func @bar(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr) {
+  llvm.call @foo(%arg0, %arg2) : (!llvm.ptr, !llvm.ptr) -> ()
+  llvm.return
+}
+
+
+// -----
+
+// CHECK-DAG: #[[DOMAIN:.*]] = #llvm.alias_scope_domain<{{.*}}>
+// CHECK-DAG: #[[$ARG0_SCOPE:.*]] = #llvm.alias_scope<id = {{.*}}, domain = #[[DOMAIN]]{{(,.*)?}}>
+// CHECK-DAG: #[[$ARG1_SCOPE:.*]] = #llvm.alias_scope<id = {{.*}}, domain = #[[DOMAIN]]{{(,.*)?}}>
+
+llvm.func @might_return_arg_derived(!llvm.ptr) -> !llvm.ptr
+
+llvm.func @foo(%arg0: !llvm.ptr {llvm.noalias}, %arg1: !llvm.ptr {llvm.noalias}) {
+  %0 = llvm.mlir.constant(5 : i64) : i32
+  %1 = llvm.call @might_return_arg_derived(%arg0) : (!llvm.ptr) -> !llvm.ptr
+  llvm.store %0, %1 : i32, !llvm.ptr
+  llvm.return
+}
+
+// CHECK-LABEL: llvm.func @bar
+// CHECK: llvm.call
+// CHECK-NOT: alias_scopes
+// CHECK-SAME: noalias_scopes = [#[[$ARG1_SCOPE]]]
+// CHECK: llvm.store
+// CHECK-NOT: alias_scopes
+// CHECK-NOT: noalias_scopes
+llvm.func @bar(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr) {
+  llvm.call @foo(%arg0, %arg2) : (!llvm.ptr, !llvm.ptr) -> ()
+  llvm.return
+}
+
+// -----
+
+// CHECK-DAG: #[[DOMAIN:.*]] = #llvm.alias_scope_domain<{{.*}}>
+// CHECK-DAG: #[[$ARG0_SCOPE:.*]] = #llvm.alias_scope<id = {{.*}}, domain = #[[DOMAIN]]{{(,.*)?}}>
+// CHECK-DAG: #[[$ARG1_SCOPE:.*]] = #llvm.alias_scope<id = {{.*}}, domain = #[[DOMAIN]]{{(,.*)?}}>
+
+llvm.func @random() -> i1
+
+llvm.func @block_arg(%arg0: !llvm.ptr {llvm.noalias}, %arg1: !llvm.ptr {llvm.noalias}) {
+  %0 = llvm.mlir.constant(5 : i64) : i32
+  %1 = llvm.call @random() : () -> i1
+  llvm.cond_br %1, ^bb0(%arg0 : !llvm.ptr), ^bb0(%arg1 : !llvm.ptr)
+
+^bb0(%arg2: !llvm.ptr):
+  llvm.store %0, %arg2 : i32, !llvm.ptr
+  llvm.return
+}
+
+// CHECK-LABEL: llvm.func @bar
+// CHECK: llvm.call
+// CHECK-NOT: alias_scopes
+// CHECK-SAME: noalias_scopes = [#[[$ARG0_SCOPE]], #[[$ARG1_SCOPE]]]
+// CHECK: llvm.store
+// CHECK: alias_scopes = [#[[$ARG0_SCOPE]], #[[$ARG1_SCOPE]]]
+llvm.func @bar(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr) {
+  llvm.call @block_arg(%arg0, %arg2) : (!llvm.ptr, !llvm.ptr) -> ()
+  llvm.return
+}
+
+// -----
+
+// CHECK-DAG: #[[DOMAIN:.*]] = #llvm.alias_scope_domain<{{.*}}>
+// CHECK-DAG: #[[$ARG0_SCOPE:.*]] = #llvm.alias_scope<id = {{.*}}, domain = #[[DOMAIN]]{{(,.*)?}}>
+// CHECK-DAG: #[[$ARG1_SCOPE:.*]] = #llvm.alias_scope<id = {{.*}}, domain = #[[DOMAIN]]{{(,.*)?}}>
+
+llvm.func @random() -> i1
+
+llvm.func @block_arg(%arg0: !llvm.ptr {llvm.noalias}, %arg1: !llvm.ptr {llvm.noalias}) {
+  %0 = llvm.mlir.constant(5 : i64) : i32
+  %1 = llvm.mlir.constant(1 : i64) : i64
+  %2 = llvm.alloca %1 x i32 : (i64) -> !llvm.ptr
+  %3 = llvm.call @random() : () -> i1
+  llvm.cond_br %3, ^bb0(%arg0 : !llvm.ptr), ^bb0(%2 : !llvm.ptr)
+
+^bb0(%arg2: !llvm.ptr):
+  llvm.store %0, %arg2 : i32, !llvm.ptr
+  llvm.return
+}
+
+// CHECK-LABEL: llvm.func @bar
+// CHECK: llvm.call
+// CHECK-NOT: alias_scopes
+// CHECK-SAME: noalias_scopes = [#[[$ARG0_SCOPE]], #[[$ARG1_SCOPE]]]
+// CHECK: llvm.store
+// CHECK-NOT: alias_scopes
+// CHECK-SAME: noalias_scopes = [#[[$ARG1_SCOPE]]]
+llvm.func @bar(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr) {
+  llvm.call @block_arg(%arg0, %arg2) : (!llvm.ptr, !llvm.ptr) -> ()
+  llvm.return
+}
+
+
+// -----
+
+// CHECK-DAG: #[[DOMAIN:.*]] = #llvm.alias_scope_domain<{{.*}}>
+// CHECK-DAG: #[[$ARG0_SCOPE:.*]] = #llvm.alias_scope<id = {{.*}}, domain = #[[DOMAIN]]{{(,.*)?}}>
+// CHECK-DAG: #[[$ARG1_SCOPE:.*]] = #llvm.alias_scope<id = {{.*}}, domain = #[[DOMAIN]]{{(,.*)?}}>
+
+llvm.func @unknown() -> !llvm.ptr
+llvm.func @random() -> i1
+
+llvm.func @unknown_object(%arg0: !llvm.ptr {llvm.noalias}, %arg1: !llvm.ptr {llvm.noalias}) {
+  %0 = llvm.mlir.constant(5 : i64) : i32
+  %1 = llvm.call @random() : () -> i1
+  %2 = llvm.call @unknown() : () -> !llvm.ptr
+  llvm.cond_br %1, ^bb0(%arg0 : !llvm.ptr), ^bb0(%2 : !llvm.ptr)
+
+^bb0(%arg2: !llvm.ptr):
+  llvm.store %0, %arg2 : i32, !llvm.ptr
+  llvm.return
+}
+
+// CHECK-LABEL: llvm.func @bar
+// CHECK: llvm.call
+// CHECK-NOT: alias_scopes
+// CHECK-SAME: noalias_scopes = [#[[$ARG0_SCOPE]], #[[$ARG1_SCOPE]]]
+// CHECK: llvm.call
+// CHECK-NOT: alias_scopes
+// CHECK-SAME: noalias_scopes = [#[[$ARG0_SCOPE]], #[[$ARG1_SCOPE]]]
+// CHECK: llvm.store
+// CHECK-NOT: alias_scopes
+// CHECK-NOT: noalias_scopes
+llvm.func @bar(%arg0: !llvm.ptr, %arg1: !llvm.ptr, %arg2: !llvm.ptr) {
+  llvm.call @unknown_object(%arg0, %arg2) : (!llvm.ptr, !llvm.ptr) -> ()
+  llvm.return
+}

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.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.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.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)