Fix an assert in collectUses when handling unknown index offsets.

AccessPathDefUseTraversal accumulates the offsets that it has seen on
the def-use walk while visiting index_addr and casts.

This is quite tricky because either the AccessPath being matched or
the def-use chain could contain unknown offsets. We need to correctly
classify all cases as either an exact, inner, or overlapping match.

For SIL like this

 %91 = integer_literal $Builtin.Int64, 0
 %113 = builtin "truncOrBitCast_Int64_Word"(%91 : $Builtin.Int64) : $Builtin.Word
 %115 = index_addr %114 : $*MyStruct, %113 : $Builtin.Word
 %119 = struct_element_addr %115 : $*MyStruct, #MyStruct.klass

We have Path: (@unknown,#0)

There are two issues

(1) When AccessPathDefUseTraversal::checkAndUpdateOffset visits the
struct_element_addr, it fails to pop the unknown offset from the
expected path but continues trying to handle the struct_element_addr
and hits an assert. This PR fixes this.

(2) If the builtin "truncOrBitCast_Int64_Word" comes from a literal,
we should not treat it as an unknown offset (given that the literal is
within the size of a word). Added a test for this case, we should be able
to identify the access path accurately in this.

Author: atrick

lib/SIL/Utils/MemAccessUtils.cpp

@@ -1256,7 +1256,7 @@ int AccessPathDefUseTraversal::getPathOffset(const DFSEntry &dfs) const {
 bool AccessPathDefUseTraversal::checkAndUpdateOffset(DFSEntry &dfs) {
   int pathOffset = getPathOffset(dfs);
   if (dfs.offset == AccessPath::UnknownOffset) {
-    if (pathOffset > 0) {
+    if (pathOffset != 0) {
       // Pop the offset from the expected path; there should only be
       // one. Continue matching subobject indices even after seeing an unknown
       // offset. A subsequent mismatching subobject index is still considered

test/SILOptimizer/accesspath_uses_ossa.sil

@@ -943,3 +943,73 @@ bb0(%0 : @owned $AnyObject):
   dealloc_stack %1 : $*Optional<AnyObject>
   return %5 : $Optional<AnyObject>
 }
+
+class Klass {
+}
+
+struct NonTrivialStruct {
+ var klass: Klass
+}
+
+sil [ossa] @get_unsafe_struct : $@convention(thin) () -> UnsafeMutablePointer<NonTrivialStruct>
+
+// TODO: Since builtin "truncOrBitCast_Int64_Word" is on a literal, we should be able to get an access path of (#0)
+// CHECK-LABEL: @test_accesspath_offset1
+// CHECK: ###For MemOp:   %8 = load_borrow %7 : $*Klass
+// CHECK: Unidentified   %3 = struct_extract %2 : $UnsafeMutablePointer<NonTrivialStruct>, #UnsafeMutablePointer._rawValue
+// CHECK: Base:   %3 = struct_extract %2 : $UnsafeMutablePointer<NonTrivialStruct>, #UnsafeMutablePointer._rawValue
+// CHECK: Storage: Unidentified   %3 = struct_extract %2 : $UnsafeMutablePointer<NonTrivialStruct>, #UnsafeMutablePointer._rawValue
+// CHECK: Path: (@Unknown,#0)
+// CHECK: Exact Uses {
+// CHECK: }
+// CHECK: Inner Uses {
+// CHECK: }
+// CHECK: Overlapping Uses {
+// CHECK:   %8 = load_borrow %7 : $*Klass
+// CHECK:   Path: (@Unknown,#0)
+// CHECK: }
+sil [ossa] @test_accesspath_offset1 : $@convention(thin) () -> () {
+bb0:
+ %0 = integer_literal $Builtin.Int64, 0
+ %1 = function_ref @get_unsafe_struct : $@convention(thin) () -> UnsafeMutablePointer<NonTrivialStruct>
+ %2 = apply %1() : $@convention(thin) () -> UnsafeMutablePointer<NonTrivialStruct>
+ %3 = struct_extract %2 : $UnsafeMutablePointer<NonTrivialStruct>, #UnsafeMutablePointer._rawValue
+ %4 = builtin "truncOrBitCast_Int64_Word"(%0 : $Builtin.Int64) : $Builtin.Word
+ %5 = pointer_to_address %3 : $Builtin.RawPointer to [strict] $*NonTrivialStruct
+ %6 = index_addr %5 : $*NonTrivialStruct, %4 : $Builtin.Word
+ %7 = struct_element_addr %6 : $*NonTrivialStruct, #NonTrivialStruct.klass
+ %8 = load_borrow %7 : $*Klass
+ end_borrow %8 : $Klass
+ %ret = tuple ()
+ return %ret : $()
+}
+
+// CHECK-LABEL: @test_accesspath_offset2
+// CHECK: ###For MemOp:   %8 = load_borrow %7 : $*Klass                   // user: %9
+// CHECK: Unidentified   %3 = struct_extract %2 : $UnsafeMutablePointer<NonTrivialStruct>, #UnsafeMutablePointer._rawValue // user: %5
+// CHECK: Base:   %3 = struct_extract %2 : $UnsafeMutablePointer<NonTrivialStruct>, #UnsafeMutablePointer._rawValue // user: %5
+// CHECK: Storage: Unidentified   %3 = struct_extract %2 : $UnsafeMutablePointer<NonTrivialStruct>, #UnsafeMutablePointer._rawValue // user: %5
+// CHECK: Path: (@Unknown,#0)
+// CHECK: Exact Uses {
+// CHECK: }
+// CHECK: Inner Uses {
+// CHECK: }
+// CHECK: Overlapping Uses {
+// CHECK:   %8 = load_borrow %7 : $*Klass                   // user: %9
+// CHECK:   Path: (@Unknown,#0)
+// CHECK: }
+sil [ossa] @test_accesspath_offset2 : $@convention(thin) (Builtin.Int64) -> () {
+bb0(%0 : $Builtin.Int64):
+ %1 = function_ref @get_unsafe_struct : $@convention(thin) () -> UnsafeMutablePointer<NonTrivialStruct>
+ %2 = apply %1() : $@convention(thin) () -> UnsafeMutablePointer<NonTrivialStruct>
+ %3 = struct_extract %2 : $UnsafeMutablePointer<NonTrivialStruct>, #UnsafeMutablePointer._rawValue
+ %4 = builtin "truncOrBitCast_Int64_Word"(%0 : $Builtin.Int64) : $Builtin.Word
+ %5 = pointer_to_address %3 : $Builtin.RawPointer to [strict] $*NonTrivialStruct
+ %6 = index_addr %5 : $*NonTrivialStruct, %4 : $Builtin.Word
+ %7 = struct_element_addr %6 : $*NonTrivialStruct, #NonTrivialStruct.klass
+ %8 = load_borrow %7 : $*Klass
+ end_borrow %8 : $Klass
+ %ret = tuple ()
+ return %ret : $()
+}
+