AccessUtils: do a simple type-based alias analysis in AccessBase.isDistinct

If the operand types (which are classes) of `ref_element_addr` or `ref_tail_addr` differ, then we know those can't be the same objects.

Author: eeckstein

SwiftCompilerSources/Sources/SIL/Utilities/AccessUtils.swift

@@ -237,6 +237,15 @@ public enum AccessBase : CustomStringConvertible, Hashable {
       }
     }
 
+    func hasDifferentType(_ lhs: Value, _ rhs: Value) -> Bool {
+      return lhs.type != rhs.type &&
+             // If the types have unbound generic arguments then we don't know
+             // the possible range of the type. A type such as $Array<Int> may
+             // alias $Array<T>.  Right now we are conservative and we assume
+             // that $UnsafeMutablePointer<T> and $Int may alias.
+             !lhs.type.hasArchetype && !rhs.type.hasArchetype
+    }
+
     func argIsDistinct(_ arg: FunctionArgument, from other: AccessBase) -> Bool {
       if arg.convention.isExclusiveIndirect {
         // Exclusive indirect arguments cannot alias with an address for which we know that it
@@ -252,16 +261,19 @@ public enum AccessBase : CustomStringConvertible, Hashable {
     // First handle all pairs of the same kind (except `yield` and `pointer`).
     case (.box(let pb), .box(let otherPb)):
       return pb.fieldIndex != otherPb.fieldIndex ||
-        isDifferentAllocation(pb.box.referenceRoot, otherPb.box.referenceRoot)
+        isDifferentAllocation(pb.box.referenceRoot, otherPb.box.referenceRoot) ||
+        hasDifferentType(pb.box, otherPb.box)
     case (.stack(let asi), .stack(let otherAsi)):
       return asi != otherAsi
     case (.global(let global), .global(let otherGlobal)):
       return global != otherGlobal
     case (.class(let rea), .class(let otherRea)):
       return rea.fieldIndex != otherRea.fieldIndex ||
-             isDifferentAllocation(rea.instance, otherRea.instance)
+             isDifferentAllocation(rea.instance, otherRea.instance) ||
+             hasDifferentType(rea.instance, otherRea.instance)
     case (.tail(let rta), .tail(let otherRta)):
-      return isDifferentAllocation(rta.instance, otherRta.instance)
+      return isDifferentAllocation(rta.instance, otherRta.instance) ||
+             hasDifferentType(rta.instance, otherRta.instance)
     case (.argument(let arg), .argument(let otherArg)):
       return (arg.convention.isExclusiveIndirect || otherArg.convention.isExclusiveIndirect) && arg != otherArg
 

test/SILOptimizer/basic-aa.sil

@@ -646,3 +646,41 @@ bb0:
   return %99 : $()
 }
 
+class GenericClass<T> {
+  var x : T
+}
+
+// CHECK-LABEL: @test_generic_class
+// CHECK:       PAIR #10.
+// CHECK-NEXT:      %2 = ref_element_addr %0 : $GenericClass<T>, #GenericClass.x
+// CHECK-NEXT:      %3 = ref_element_addr %1 : $GenericClass<Int>, #GenericClass.x
+// CHECK-NEXT:    MayAlias
+sil [ossa] @test_generic_class : $@convention(thin) <T> (@guaranteed GenericClass<T>, @guaranteed GenericClass<Int>) -> () {
+bb0(%0 : @guaranteed $GenericClass<T>, %1 : @guaranteed $GenericClass<Int>):
+  %2 = ref_element_addr %0 : $GenericClass<T>, #GenericClass.x
+  %3 = ref_element_addr %1 : $GenericClass<Int>, #GenericClass.x
+
+  fix_lifetime %2 : $*T
+  fix_lifetime %3 : $*Int
+
+  %9999 = tuple()
+  return %9999 : $()
+}
+
+// CHECK-LABEL: @test_bound_generic_class
+// CHECK:       PAIR #10.
+// CHECK-NEXT:      %2 = ref_element_addr %0 : $GenericClass<Int32>, #GenericClass.x
+// CHECK-NEXT:      %3 = ref_element_addr %1 : $GenericClass<Int>, #GenericClass.x
+// CHECK-NEXT:    NoAlias
+sil [ossa] @test_bound_generic_class : $@convention(thin) (@guaranteed GenericClass<Int32>, @guaranteed GenericClass<Int>) -> () {
+bb0(%0 : @guaranteed $GenericClass<Int32>, %1 : @guaranteed $GenericClass<Int>):
+  %2 = ref_element_addr %0 : $GenericClass<Int32>, #GenericClass.x
+  %3 = ref_element_addr %1 : $GenericClass<Int>, #GenericClass.x
+
+  fix_lifetime %2 : $*Int32
+  fix_lifetime %3 : $*Int
+
+  %9999 = tuple()
+  return %9999 : $()
+}
+