Optimizer: simplify unchecked_addr_cast for vectors

Reimplement the simplification in swift and add a new transformation:
```
  %1 = unchecked_addr_cast %0 : $*Builtin.FixedArray<N, Element> to $*Element
```
->
```
  %1 = vector_base_addr %0 : $*Builtin.FixedArray<N, Element>
```

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -39,6 +39,7 @@ swift_compiler_sources(Optimizer
   SimplifySwitchEnum.swift
   SimplifyTuple.swift
   SimplifyTupleExtract.swift
+  SimplifyUncheckedAddrCast.swift
   SimplifyUncheckedEnumData.swift
   SimplifyValueToBridgeObject.swift
   SimplifyWitnessMethod.swift)

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyUncheckedAddrCast.swift

@@ -0,0 +1,81 @@
+//===--- SimplifyUncheckedAddrCast.swift ----------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+
+extension UncheckedAddrCastInst : OnoneSimplifiable, SILCombineSimplifiable {
+
+  func simplify(_ context: SimplifyContext) {
+    // ```
+    //   %1 = unchecked_addr_cast %0 : $*T to $*T
+    // ```
+    // ->
+    //   replace %1 with %0
+    //
+    if optimizeSameTypeCast(context) {
+      return
+    }
+
+    // ```
+    //   %1 = unchecked_addr_cast %0 : $*U to $*V
+    //   %2 = unchecked_addr_cast %1 : $*V to $*T
+    // ```
+    // ->
+    // ```
+    //   %2 = unchecked_addr_cast %0: $*U to $*T
+    // ```
+    if optimizeDoubleCast(context) {
+      return
+    }
+
+    // ```
+    //   %1 = unchecked_addr_cast %0 : $*Builtin.FixedArray<N, Element> to $*Element
+    // ```
+    // ->
+    // ```
+    //   %1 = vector_base_addr %0 : $*Builtin.FixedArray<N, Element>
+    // ```
+    _ = optimizeVectorBaseCast(context)
+  }
+}
+
+private extension UncheckedAddrCastInst {
+  func optimizeSameTypeCast(_ context: SimplifyContext) -> Bool {
+    if fromAddress.type == type {
+      self.replace(with: fromAddress, context)
+      return true
+    }
+    return false
+  }
+
+  func optimizeDoubleCast(_ context: SimplifyContext) -> Bool {
+    if let firstCast = fromAddress as? UncheckedAddrCastInst {
+      let builder = Builder(before: self, context)
+      let newCast = builder.createUncheckedAddrCast(from: firstCast.fromAddress, to: type)
+      self.replace(with: newCast, context)
+      return true
+    }
+    return false
+  }
+
+  func optimizeVectorBaseCast(_ context: SimplifyContext) -> Bool {
+    if fromAddress.type.isBuiltinFixedArray,
+       fromAddress.type.builtinFixedArrayElementType(in: parentFunction, maximallyAbstracted: true).addressType == type
+    {
+      let builder = Builder(before: self, context)
+      let vectorBase = builder.createVectorBaseAddr(vector: fromAddress)
+      self.replace(with: vectorBase, context)
+      return true
+    }
+    return false
+  }
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -125,6 +125,7 @@ private func registerSwiftPasses() {
   registerForSILCombine(PointerToAddressInst.self,  { run(PointerToAddressInst.self, $0) })
   registerForSILCombine(UncheckedEnumDataInst.self, { run(UncheckedEnumDataInst.self, $0) })
   registerForSILCombine(WitnessMethodInst.self,     { run(WitnessMethodInst.self, $0) })
+  registerForSILCombine(UncheckedAddrCastInst.self, { run(UncheckedAddrCastInst.self, $0) })
   registerForSILCombine(UnconditionalCheckedCastInst.self, { run(UnconditionalCheckedCastInst.self, $0) })
   registerForSILCombine(AllocStackInst.self,        { run(AllocStackInst.self, $0) })
   registerForSILCombine(ApplyInst.self,             { run(ApplyInst.self, $0) })

lib/SILOptimizer/Analysis/SimplifyInstruction.cpp

@@ -52,7 +52,6 @@ namespace {
     SILValue
     visitUnconditionalCheckedCastInst(UnconditionalCheckedCastInst *UCCI);
     SILValue visitUncheckedRefCastInst(UncheckedRefCastInst *OPRI);
-    SILValue visitUncheckedAddrCastInst(UncheckedAddrCastInst *UACI);
     SILValue visitStructInst(StructInst *SI);
     SILValue visitTupleInst(TupleInst *SI);
     SILValue visitBuiltinInst(BuiltinInst *AI);
@@ -357,21 +356,6 @@ visitUncheckedRefCastInst(UncheckedRefCastInst *OPRI) {
   return simplifyDeadCast(OPRI);
 }
 
-SILValue
-InstSimplifier::
-visitUncheckedAddrCastInst(UncheckedAddrCastInst *UACI) {
-  // (unchecked-addr-cast Y->X (unchecked-addr-cast x X->Y)) -> x
-  if (auto *OtherUACI = dyn_cast<UncheckedAddrCastInst>(&*UACI->getOperand()))
-    if (OtherUACI->getOperand()->getType() == UACI->getType())
-      return OtherUACI->getOperand();
-
-  // (unchecked-addr-cast X->X x) -> x
-  if (UACI->getOperand()->getType() == UACI->getType())
-    return UACI->getOperand();
-
-  return SILValue();
-}
-
 SILValue InstSimplifier::visitUpcastInst(UpcastInst *UI) {
   // (upcast Y->X (unchecked-ref-cast x X->Y)) -> x
   if (auto *URCI = dyn_cast<UncheckedRefCastInst>(UI->getOperand()))

lib/SILOptimizer/SILCombiner/SILCombiner.h

@@ -260,7 +260,6 @@ class SILCombiner :
   bool optimizeStackAllocatedEnum(AllocStackInst *AS);
   SILInstruction *visitSwitchEnumAddrInst(SwitchEnumAddrInst *SEAI);
   SILInstruction *visitInjectEnumAddrInst(InjectEnumAddrInst *IEAI);
-  SILInstruction *visitUncheckedAddrCastInst(UncheckedAddrCastInst *UADCI);
   SILInstruction *visitUncheckedRefCastInst(UncheckedRefCastInst *URCI);
   SILInstruction *visitEndCOWMutationInst(EndCOWMutationInst *URCI);
   SILInstruction *visitUncheckedRefCastAddrInst(UncheckedRefCastAddrInst *URCI);

lib/SILOptimizer/SILCombiner/SILCombinerCastVisitors.cpp

@@ -219,23 +219,6 @@ SILInstruction *SILCombiner::visitUpcastInst(UpcastInst *uci) {
   return nullptr;
 }
 
-SILInstruction *
-SILCombiner::visitUncheckedAddrCastInst(UncheckedAddrCastInst *UADCI) {
-  // These are always safe to perform due to interior pointer ownership
-  // requirements being transitive along addresses.
-
-  Builder.setCurrentDebugScope(UADCI->getDebugScope());
-
-  // (unchecked_addr_cast (unchecked_addr_cast x X->Y) Y->Z)
-  //   ->
-  // (unchecked_addr_cast x X->Z)
-  if (auto *OtherUADCI = dyn_cast<UncheckedAddrCastInst>(UADCI->getOperand()))
-    return Builder.createUncheckedAddrCast(UADCI->getLoc(),
-                                           OtherUADCI->getOperand(),
-                                           UADCI->getType());
-  return nullptr;
-}
-
 SILInstruction *
 SILCombiner::visitUncheckedRefCastInst(UncheckedRefCastInst *urci) {
   // %0 = unchecked_ref_cast %x : $X->Y

lib/SILOptimizer/SILCombiner/Simplifications.def

@@ -47,6 +47,7 @@ INSTRUCTION_SIMPLIFICATION(DestructureStructInst)
 INSTRUCTION_SIMPLIFICATION(DestructureTupleInst)
 INSTRUCTION_SIMPLIFICATION(PointerToAddressInst)
 INSTRUCTION_SIMPLIFICATION(TypeValueInst)
+INSTRUCTION_SIMPLIFICATION(UncheckedAddrCastInst)
 INSTRUCTION_SIMPLIFICATION(UncheckedEnumDataInst)
 INSTRUCTION_SIMPLIFICATION(WitnessMethodInst)
 INSTRUCTION_SIMPLIFICATION_WITH_LEGACY(AllocStackInst)

test/SILOptimizer/simplify_unchecked_addr_cast.sil

@@ -0,0 +1,73 @@
+// RUN: %target-sil-opt %s -onone-simplification -simplify-instruction=unchecked_addr_cast | %FileCheck %s
+// RUN: %target-sil-opt %s -simplification -simplify-instruction=unchecked_addr_cast | %FileCheck %s
+
+import Swift
+import Builtin
+
+// CHECK-LABEL: sil [ossa] @same_type :
+// CHECK-NOT:     unchecked_addr_cast
+// CHECK:         %1 = load [trivial] %0
+// CHECK:      } // end sil function 'same_type'
+sil [ossa] @same_type : $@convention(thin) (@inout Int) -> Int {
+bb0(%0 : $*Int):
+  %1 = unchecked_addr_cast %0 to $*Int
+  %2 = load [trivial] %1
+  return %2
+}
+
+// CHECK-LABEL: sil [ossa] @not_same_type :
+// CHECK:         %1 = unchecked_addr_cast %0 to $*Float
+// CHECK:         %2 = load [trivial] %1
+// CHECK:      } // end sil function 'not_same_type'
+sil [ossa] @not_same_type : $@convention(thin) (@inout Int) -> Float {
+bb0(%0 : $*Int):
+  %1 = unchecked_addr_cast %0 to $*Float
+  %2 = load [trivial] %1
+  return %2
+}
+
+// CHECK-LABEL: sil [ossa] @double_cast :
+// CHECK:         %1 = unchecked_addr_cast %0 to $*Bool
+// CHECK:         %2 = load [trivial] %1
+// CHECK:      } // end sil function 'double_cast'
+sil [ossa] @double_cast : $@convention(thin) (@inout Int) -> Bool {
+bb0(%0 : $*Int):
+  %1 = unchecked_addr_cast %0 to $*Float
+  %2 = unchecked_addr_cast %1 to $*Bool
+  %3 = load [trivial] %2
+  return %3
+}
+
+// CHECK-LABEL: sil [ossa] @vector_base :
+// CHECK:         %1 = vector_base_addr %0
+// CHECK:         %2 = load [trivial] %1
+// CHECK:      } // end sil function 'vector_base'
+sil [ossa] @vector_base : $@convention(thin) (@inout Builtin.FixedArray<10, Int>) -> Int {
+bb0(%0 : $*Builtin.FixedArray<10, Int>):
+  %1 = unchecked_addr_cast %0 to $*Int
+  %2 = load [trivial] %1
+  return %2
+}
+
+// CHECK-LABEL: sil [ossa] @vector_base_wrong_type :
+// CHECK:         %1 = unchecked_addr_cast %0 to $*Bool
+// CHECK:         %2 = load [trivial] %1
+// CHECK:      } // end sil function 'vector_base_wrong_type'
+sil [ossa] @vector_base_wrong_type : $@convention(thin) (@inout Builtin.FixedArray<10, Int>) -> Bool {
+bb0(%0 : $*Builtin.FixedArray<10, Int>):
+  %1 = unchecked_addr_cast %0 to $*Bool
+  %2 = load [trivial] %1
+  return %2
+}
+
+// CHECK-LABEL: sil [ossa] @vector_base_function_type :
+// CHECK:         %1 = vector_base_addr %0
+// CHECK:         %2 = load [copy] %1
+// CHECK:      } // end sil function 'vector_base_function_type'
+sil [ossa] @vector_base_function_type : $@convention(thin) (@inout Builtin.FixedArray<10, ()->()>) -> @owned @callee_guaranteed @substituted <τ_0_0> () -> @out τ_0_0 for <()> {
+bb0(%0 : $*Builtin.FixedArray<10, ()->()>):
+  %1 = unchecked_addr_cast %0 to $*@callee_guaranteed @substituted <τ_0_0> () -> @out τ_0_0 for <()>
+  %2 = load [copy] %1
+  return %2
+}
+