LoopInvariantCodeMotion: correctly create projections for owned values

Owned structs and tuples must be projected by `destructure_struct` and `destructure_tuple`, respectively.

rdar://161467837

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -125,20 +125,32 @@ extension Value {
     return true
   }
 
+  /// Project out a sub-field of this value according to `path`.
+  /// If this is an "owned" value the result is an "owned" value which forwards the original value.
+  /// This only works if _all_ non-trivial fields are projected. Otherwise some non-trivial results of
+  /// `destructure_struct` or `destructure_tuple` will be leaked.
   func createProjection(path: SmallProjectionPath, builder: Builder) -> Value {
     let (kind, index, subPath) = path.pop()
+    let result: Value
     switch kind {
     case .root:
       return self
     case .structField:
-      let structExtract = builder.createStructExtract(struct: self, fieldIndex: index)
-      return structExtract.createProjection(path: subPath, builder: builder)
+      if ownership == .owned {
+        result = builder.createDestructureStruct(struct: self).results[index]
+      } else {
+        result = builder.createStructExtract(struct: self, fieldIndex: index)
+      }
     case .tupleField:
-      let tupleExtract = builder.createTupleExtract(tuple: self, elementIndex: index)
-      return tupleExtract.createProjection(path: subPath, builder: builder)
+      if ownership == .owned {
+        result = builder.createDestructureTuple(tuple: self).results[index]
+      } else {
+        result = builder.createTupleExtract(tuple: self, elementIndex: index)
+      }
     default:
       fatalError("path is not materializable")
     }
+    return result.createProjection(path: subPath, builder: builder)
   }
 
   func createAddressProjection(path: SmallProjectionPath, builder: Builder) -> Value {

test/SILOptimizer/licm.sil

@@ -2005,3 +2005,30 @@ bb3:
   return %r
 }
 
+// CHECK-LABEL: sil [ossa] @projected_load_take :
+// CHECK:       bb1([[V:%.*]] : @owned $(S, Int)):
+// CHECK-NEXT:    ([[E:%.*]], {{%[0-9]+}}) = destructure_tuple [[V]]
+// CHECK-NEXT:    ({{%[0-9]+}}, [[S:%.*]]) = destructure_struct [[E]]
+// CHECK-NEXT:    = struct $S (%1 : $Int, [[S]] : $String)
+// CHECK-LABEL: } // end sil function 'projected_load_take'
+sil [ossa] @projected_load_take : $@convention(thin) (@inout (S, Int), Int) -> () {
+bb0(%0 : $*(S, Int), %1 : $Int):
+  br bb1
+
+bb1:
+  %2 = tuple_element_addr %0, 0
+  %3 = struct_element_addr %2, #S.s
+  %4 = load [take] %3
+  %5 = struct $S (%1, %4)
+  %6 = tuple (%5, %1)
+  store %6 to [init] %0
+  cond_br undef, bb2, bb3
+
+bb2:
+  br bb1
+
+bb3:
+  %r = tuple ()
+  return %r
+}
+