AliasAnalysis: conservatively assume @inout may alias, part 2

Use the new swift::isNotAliasingArgument utility function to check for a not-aliased arguments.

Author: eeckstein

lib/SILOptimizer/Analysis/AliasAnalysis.cpp

@@ -112,18 +112,12 @@ static bool isFunctionArgument(SILValue V) {
   return Arg->isFunctionArg();
 }
 
-/// A no alias argument is an argument that is an address type of the entry
-/// basic block of a function.
-static bool isNoAliasArgument(SILValue V) {
-  return isFunctionArgument(V) && V.getType().isAddress();
-}
-
 /// Return true if V is an object that at compile time can be uniquely
 /// identified.
 static bool isIdentifiableObject(SILValue V) {
   if (isa<AllocationInst>(V) || isa<LiteralInst>(V))
     return true;
-  if (isNoAliasArgument(V))
+  if (isNotAliasingArgument(V))
     return true;
   return false;
 }
@@ -173,7 +167,8 @@ static bool isLocalLiteral(SILValue V) {
 /// Is this a value that can be unambiguously identified as being defined at the
 /// function level.
 static bool isIdentifiedFunctionLocal(SILValue V) {
-  return isa<AllocationInst>(*V) || isNoAliasArgument(V) || isLocalLiteral(V);
+  return isa<AllocationInst>(*V) || isNotAliasingArgument(V) ||
+         isLocalLiteral(V);
 }
 
 /// Returns true if we can prove that the two input SILValues which do not equal

test/SILOptimizer/basic-aa.sil

@@ -16,7 +16,7 @@ import Swift
 // CHECK-NEXT: %0 = argument of bb0
 // CHECK-NEXT: %1 = argument of bb0
 // CHECK-NEXT: NoAlias
-sil @address_args_dont_alias_in_first_bb : $@convention(thin) (@inout Builtin.NativeObject, @inout Builtin.NativeObject) -> () {
+sil @address_args_dont_alias_in_first_bb : $@convention(thin) (@in Builtin.NativeObject, @in Builtin.NativeObject) -> () {
 bb0(%0 : $*Builtin.NativeObject, %1 : $*Builtin.NativeObject):
   %2 = tuple()
   return %2 : $()
@@ -37,6 +37,19 @@ bb1(%1 : $*Builtin.NativeObject, %2 : $*Builtin.NativeObject):
   return %3 : $()
 }
 
+// Assume that inout arguments alias to preserve memory safety.
+//
+// CHECK-LABEL: @inout_args_may_alias
+// CHECK: PAIR #1.
+// CHECK-NEXT: %0 = argument of bb0
+// CHECK-NEXT: %1 = argument of bb0
+// CHECK-NEXT: MayAlias
+sil @inout_args_may_alias: $@convention(thin) (@inout Builtin.NativeObject, @inout Builtin.NativeObject) -> () {
+bb0(%0 : $*Builtin.NativeObject, %1 : $*Builtin.NativeObject):
+  %2 = tuple()
+  return %2 : $()
+}
+
 struct StructLvl2 {
   var tup : (Builtin.Int64, Builtin.Int32)
 }
@@ -200,7 +213,7 @@ sil @different_alloc_stack_dont_alias : $@convention(thin) () -> () {
 // CHECK-NEXT: (0):   %2 = argument of bb0 : $*Builtin.NativeObject
 // CHECK-NEXT: (1):   %3 = alloc_stack $Builtin.NativeObject
 // CHECK-NEXT: NoAlias
-sil @args_dont_alias_with_identified_function_locals : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject, @inout Builtin.NativeObject) -> () {
+sil @args_dont_alias_with_identified_function_locals : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject, @in Builtin.NativeObject) -> () {
 bb0(%0 : $Builtin.NativeObject, %1 : $Builtin.NativeObject, %2 : $*Builtin.NativeObject):
   %3 = alloc_stack $Builtin.NativeObject
   dealloc_stack %3#0 : $*@local_storage Builtin.NativeObject

test/SILOptimizer/mem-behavior.sil

@@ -58,7 +58,7 @@ bb0(%0 : $Int32, %1 : $*Int32, %2 : $*Int32):
 // CHECK-NEXT:  (0):   %4 = apply %3(%0, %1) : $@convention(thin) (Int32, @inout Int32) -> ()
 // CHECK-NEXT:  (0):   %2 = argument of bb0 : $*Int32
 // CHECK-NEXT:  r=0,w=0,se=0
-sil @call_store_to_int_not_aliased : $@convention(thin) (Int32, @inout Int32, @inout Int32) -> () {
+sil @call_store_to_int_not_aliased : $@convention(thin) (Int32, @inout Int32, @in Int32) -> () {
 bb0(%0 : $Int32, %1 : $*Int32, %2 : $*Int32):
   %3 = function_ref @store_to_int : $@convention(thin) (Int32, @inout Int32) -> ()
   %4 = apply %3(%0, %1) : $@convention(thin) (Int32, @inout Int32) -> ()