[mlir] LocalAliasAnalysis: Assume allocation scope to function scope if cannot determine better

[Hardcode84]

Summary

It helps when checking aliasing between AllocOp result and function arguments.

[rriddle]

Right, this works because of how we defined the nature of the Allocate effect. Going under that definition, I think we could technically just check dominance to see if an alias is possible. LGTM

mlir/test/Analysis/test-alias-analysis.mlir

17

This should be dropped now.

mlir/lib/Analysis/AliasAnalysis/LocalAliasAnalysis.cpp

 //===- LocalAliasAnalysis.cpp - Local stateless alias Analysis for MLIR ---===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Analysis/AliasAnalysis/LocalAliasAnalysis.h"
 
+#include "mlir/IR/FunctionSupport.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/Interfaces/ControlFlowInterfaces.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 #include "mlir/Interfaces/ViewLikeInterface.h"
 
 using namespace mlir;
 
 //===----------------------------------------------------------------------===//
getAllocEffectFor(Value value, Optional<MemoryEffects::EffectInstance> &effect,
   if (llvm::isa<SideEffects::AutomaticAllocationScopeResource>(
           effect->getResource())) {
     allocScopeOp = op->getParentWithTrait<OpTrait::AutomaticAllocationScope>();
     return success();
   }
 
   // TODO: Here we could look at the users to see if the resource is either
   // freed on all paths within the region, or is just not captured by anything.
-  allocScopeOp = nullptr;
+  // For now assume allocation scope to the function scope (we don't care if
+  // pointer escape outside function).
+  allocScopeOp = op->getParentWithTrait<OpTrait::FunctionLike>();
   return success();
 }
 
 /// Given the two values, return their aliasing behavior.
 static AliasResult aliasImpl(Value lhs, Value rhs) {
   if (lhs == rhs)
     return AliasResult::MustAlias;
   Operation *lhsAllocScope = nullptr, *rhsAllocScope = nullptr;

mlir/test/Analysis/test-alias-analysis.mlir

 // RUN: mlir-opt %s -pass-pipeline='func(test-alias-analysis)' -split-input-file -allow-unregistered-dialect 2>&1 | FileCheck %s
 
 // CHECK-LABEL: Testing : "simple"
 // CHECK-DAG: func.region0#0 <-> func.region0#1: MayAlias
 
 // CHECK-DAG: alloca_1#0 <-> alloca_2#0: NoAlias
 // CHECK-DAG: alloca_1#0 <-> alloc_1#0: NoAlias
 // CHECK-DAG: alloca_1#0 <-> alloc_2#0: NoAlias
 // CHECK-DAG: alloca_1#0 <-> func.region0#0: NoAlias
 // CHECK-DAG: alloca_1#0 <-> func.region0#1: NoAlias
 
 // CHECK-DAG: alloca_2#0 <-> alloc_1#0: NoAlias
 // CHECK-DAG: alloca_2#0 <-> alloc_2#0: NoAlias
 // CHECK-DAG: alloca_2#0 <-> func.region0#0: NoAlias
 // CHECK-DAG: alloca_2#0 <-> func.region0#1: NoAlias
 
 // TODO: The MayAlias below is overly conservative and should be provably
 // NoAlias with a proper escape analysis.
 // CHECK-DAG: alloc_1#0 <-> alloc_2#0: NoAlias
-// CHECK-DAG: alloc_1#0 <-> func.region0#0: MayAlias
-// CHECK-DAG: alloc_1#0 <-> func.region0#1: MayAlias
+// CHECK-DAG: alloc_1#0 <-> func.region0#0: NoAlias
+// CHECK-DAG: alloc_1#0 <-> func.region0#1: NoAlias
 
-// CHECK-DAG: alloc_2#0 <-> func.region0#0: MayAlias
-// CHECK-DAG: alloc_2#0 <-> func.region0#1: MayAlias
+// CHECK-DAG: alloc_2#0 <-> func.region0#0: NoAlias
+// CHECK-DAG: alloc_2#0 <-> func.region0#1: NoAlias
 func @simple(%arg: memref<2xf32>, %arg1: memref<2xf32>) attributes {test.ptr = "func"} {
   %0 = memref.alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
   %1 = memref.alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
   %2 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
   %3 = memref.alloc() {test.ptr = "alloc_2"} : memref<8x64xf32>
   return
 }
 

 
 // CHECK-DAG: alloca_2#0 <-> func.region0.block1#0: NoAlias
 // CHECK-DAG: alloca_2#0 <-> func.region0.block2#0: NoAlias
 
 // CHECK-DAG: alloc_1#0 <-> func.region0.block1#0: NoAlias
 // CHECK-DAG: alloc_1#0 <-> func.region0.block2#0: MayAlias
 
 // CHECK-DAG: func.region0#0 <-> func.region0.block1#0: NoAlias
-// CHECK-DAG: func.region0#0 <-> func.region0.block2#0: MayAlias
+// CHECK-DAG: func.region0#0 <-> func.region0.block2#0: NoAlias
 
 // CHECK-DAG: func.region0#1 <-> func.region0.block1#0: NoAlias
-// CHECK-DAG: func.region0#1 <-> func.region0.block2#0: MayAlias
+// CHECK-DAG: func.region0#1 <-> func.region0.block2#0: NoAlias
 
 // CHECK-DAG: func.region0.block1#0 <-> func.region0.block2#0: MayAlias
 func @control_flow_merge(%arg: memref<2xf32>, %cond: i1) attributes {test.ptr = "func"} {
   %0 = memref.alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
   %1 = memref.alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
   %2 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
 
   cond_br %cond, ^bb1(%0 : memref<8x64xf32>), ^bb2(%2 : memref<8x64xf32>)

 // CHECK-DAG: if_alloca#0 <-> if_alloc#0: NoAlias
 // CHECK-DAG: if_alloca#0 <-> func.region0#0: NoAlias
 // CHECK-DAG: if_alloca#0 <-> func.region0#1: NoAlias
 
 // CHECK-DAG: if_alloca_merge#0 <-> if_alloc#0: NoAlias
 // CHECK-DAG: if_alloca_merge#0 <-> func.region0#0: NoAlias
 // CHECK-DAG: if_alloca_merge#0 <-> func.region0#1: NoAlias
 
-// CHECK-DAG: if_alloc#0 <-> func.region0#0: MayAlias
-// CHECK-DAG: if_alloc#0 <-> func.region0#1: MayAlias
+// CHECK-DAG: if_alloc#0 <-> func.region0#0: NoAlias
+// CHECK-DAG: if_alloc#0 <-> func.region0#1: NoAlias
 func @region_control_flow(%arg: memref<2xf32>, %cond: i1) attributes {test.ptr = "func"} {
   %0 = memref.alloca() {test.ptr = "alloca_1"} : memref<8x64xf32>
   %1 = memref.alloca() {test.ptr = "alloca_2"} : memref<8x64xf32>
   %2 = memref.alloc() {test.ptr = "alloc_1"} : memref<8x64xf32>
 
   %3 = scf.if %cond -> (memref<8x64xf32>) {
     scf.yield %0 : memref<8x64xf32>
   } else {