Merge pull request #78290 from eeckstein/sil-infrastructure

Some AST and SIL infrastructure additions and improvements

Author: eeckstein

SwiftCompilerSources/Sources/AST/SubstitutionMap.swift

@@ -56,4 +56,14 @@ public struct SubstitutionMap: CustomStringConvertible {
       return Conformance(bridged: bridgedSubs.getConformance(index))
     }
   }
+
+  public var replacementTypes: TypeArray {
+    TypeArray(bridged: bridged.getReplacementTypes())
+  }
+
+  /// The single replacement type if it's guarnateed that the substitution map has a single replacement type.
+  public var replacementType: Type {
+    assert(replacementTypes.count == 1)
+    return replacementTypes[0]
+  }
 }

SwiftCompilerSources/Sources/AST/Type.swift

@@ -46,6 +46,12 @@ public struct Type: CustomStringConvertible, NoReflectionChildren {
 /// A Type that is statically known to be canonical.
 /// For example, typealiases are resolved.
 public struct CanonicalType: CustomStringConvertible, NoReflectionChildren {
+  public enum TraitResult {
+    case isNot
+    case canBe
+    case `is`
+  }
+
   public let bridged: BridgedCanType
 
   public init(bridged: BridgedCanType) { self.bridged = bridged }
@@ -63,4 +69,38 @@ public struct CanonicalType: CustomStringConvertible, NoReflectionChildren {
   public func subst(with substitutionMap: SubstitutionMap) -> CanonicalType {
     return type.subst(with: substitutionMap).canonical
   }
+
+  public var canBeClass: TraitResult { bridged.canBeClass().result }
+}
+
+public struct TypeArray : RandomAccessCollection, CustomReflectable {
+  public let bridged: BridgedASTTypeArray
+
+  public var startIndex: Int { return 0 }
+  public var endIndex: Int { return bridged.getCount() }
+
+  public init(bridged: BridgedASTTypeArray) {
+    self.bridged = bridged
+  }
+
+  public subscript(_ index: Int) -> Type {
+    Type(bridged: bridged.getAt(index))
+  }
+
+  public var customMirror: Mirror {
+    let c: [Mirror.Child] = map { (label: nil, value: $0) }
+    return Mirror(self, children: c)
+  }
+}
+
+extension BridgedCanType.TraitResult {
+  var result: CanonicalType.TraitResult {
+    switch self {
+    case .IsNot: return .isNot
+    case .CanBe: return .canBe
+    case .Is:    return .is
+    default:
+      fatalError("wrong type TraitResult enum case")
+    }
+  }
 }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AllocVectorLowering.swift

@@ -224,9 +224,10 @@ private func createOutlinedGlobal(
     return
   }
 
-  let elementType = allocVectorBuiltin.substitutionMap.replacementTypes[0]!
+  let function = allocVectorBuiltin.parentFunction
+  let elementType = allocVectorBuiltin.substitutionMap.replacementTypes[0].loweredType(in: function)
   let outlinedGlobal = context.createGlobalVariable(
-        name: context.mangleOutlinedVariable(from: allocVectorBuiltin.parentFunction),
+        name: context.mangleOutlinedVariable(from: function),
         type: elementType, linkage: .private, isLet: false)
 
   let globalBuilder = Builder(staticInitializerOf: outlinedGlobal, context)
@@ -249,8 +250,7 @@ private func createOutlinedGlobal(
   let globalAddr = builder.createGlobalAddr(global: outlinedGlobal, dependencyToken: nil)
   let rawVectorPointer = builder.createAddressToPointer(address: globalAddr, pointerType: allocVectorBuiltin.type,
                                                         needStackProtection: false)
-  allocVectorBuiltin.uses.replaceAll(with: rawVectorPointer, context)
-  context.erase(instruction: allocVectorBuiltin)
+  allocVectorBuiltin.replace(with: rawVectorPointer, context)
 }
 
 private func createStackAllocatedVector(
@@ -259,13 +259,13 @@ private func createStackAllocatedVector(
   _ context: FunctionPassContext
 ) {
   let builder = Builder(before: allocVectorBuiltin, context)
-  let elementType = allocVectorBuiltin.substitutionMap.replacementTypes[0]!
+  let function = allocVectorBuiltin.parentFunction
+  let elementType = allocVectorBuiltin.substitutionMap.replacementTypes[0].loweredType(in: function)
   let allocVec = builder.createAllocVector(capacity: allocVectorBuiltin.operands[1].value, elementType: elementType)
   let rawVectorPointer = builder.createAddressToPointer(address: allocVec, pointerType: allocVectorBuiltin.type,
                                                         needStackProtection: true)
 
-  allocVectorBuiltin.uses.replaceAll(with: rawVectorPointer, context)
-  context.erase(instruction: allocVectorBuiltin)
+  allocVectorBuiltin.replace(with: rawVectorPointer, context)
 
   for endInst in liverange.ends {
     let builder = Builder(after: endInst, context)

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ClosureSpecialization.swift

@@ -301,8 +301,7 @@ private func rewriteApplyInstruction(using specializedCallee: Function, callSite
     }
   }
 
-  oldApply.uses.replaceAll(with: newApply, context)
-  context.erase(instruction: oldApply)
+  oldApply.replace(with: newApply, context)
 }
 
 // ===================== Utility functions and extensions ===================== //
@@ -1381,4 +1380,4 @@ let rewrittenCallerBodyTest = FunctionTest("closure_specialize_rewritten_caller_
     print("Rewritten caller body for: \(function.name):")
     print("\(function)\n")
   }
-}
+}

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CopyToBorrowOptimization.swift

@@ -260,8 +260,7 @@ private extension LoadInst {
 private func remove(copy: CopyValueInst, collectedUses: Uses, liverange: InstructionRange) {
   let context = collectedUses.context
   replaceMoveWithBorrow(of: copy, replacedBy: copy.fromValue, liverange: liverange, collectedUses: collectedUses)
-  copy.uses.replaceAll(with: copy.fromValue, context)
-  context.erase(instruction: copy)
+  copy.replace(with: copy.fromValue, context)
 
   for forwardingUse in collectedUses.forwardingUses {
     forwardingUse.changeOwnership(from: .owned, to: .guaranteed, context)
@@ -301,8 +300,7 @@ private func replaceMoveWithBorrow(
                                       isLexical: moveInst.isLexical,
                                       hasPointerEscape: moveInst.hasPointerEscape,
                                       isFromVarDecl: moveInst.isFromVarDecl)
-  moveInst.uses.replaceAll(with: bbi, context)
-  context.erase(instruction: moveInst)
+  moveInst.replace(with: bbi, context)
   createEndBorrows(for: bbi, atEndOf: liverange, collectedUses: collectedUses)
 }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjCBridgingOptimization.swift

@@ -152,8 +152,7 @@ private func optimizeNonOptionalBridging(_ apply: ApplyInst,
     let replacement = builder.createUncheckedEnumData(enum: optionalReplacement,
                                                       caseIndex: someCase,
                                                       resultType: bridgeToObjcCall.type)
-    bridgeToObjcCall.uses.replaceAll(with: replacement, context)
-    context.erase(instruction: bridgeToObjcCall)
+    bridgeToObjcCall.replace(with: replacement, context)
     return true
   }
 
@@ -219,8 +218,7 @@ private func optimizeNonOptionalBridging(_ apply: ApplyInst,
 
   // Now replace the bridged value with the original value in the destination block.
   let replacement = s.makeAvailable(in: bridgeToObjcCall.parentBlock, context)
-  bridgeToObjcCall.uses.replaceAll(with: replacement, context)
-  context.erase(instruction: bridgeToObjcCall)
+  bridgeToObjcCall.replace(with: replacement, context)
   return true
 }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -413,8 +413,7 @@ private func replace(object allocRef: AllocRefInstBase,
   }
 
   rewriteUses(of: allocRef, context)
-  allocRef.uses.replaceAll(with: globalValue, context)
-  context.erase(instruction: allocRef)
+  allocRef.replace(with: globalValue, context)
   return globalValue
 }
 
@@ -431,13 +430,11 @@ private func rewriteUses(of startValue: Value, _ context: FunctionPassContext) {
       if !beginDealloc.parentFunction.hasOwnership {
         builder.createStrongRelease(operand: beginDealloc.reference)
       }
-      beginDealloc.uses.replaceAll(with: beginDealloc.reference, context)
-      context.erase(instruction: beginDealloc)
+      beginDealloc.replace(with: beginDealloc.reference, context)
     case is EndCOWMutationInst, is EndInitLetRefInst, is MoveValueInst:
       let svi = inst as! SingleValueInstruction
       worklist.pushIfNotVisited(usersOf: svi)
-      svi.uses.replaceAll(with: svi.operands[0].value, context)
-      context.erase(instruction: svi)
+      svi.replace(with: svi.operands[0].value, context)
     case let upCast as UpcastInst:
       worklist.pushIfNotVisited(usersOf: upCast)
     case let refCast as UncheckedRefCastInst:
@@ -454,7 +451,7 @@ private func rewriteUses(of startValue: Value, _ context: FunctionPassContext) {
 
 private extension InstructionWorklist {
   mutating func pushIfNotVisited(usersOf value: Value) {
-    pushIfNotVisited(contentsOf: value.uses.lazy.map { $0.instruction })
+    pushIfNotVisited(contentsOf: value.users)
   }
 }
 
@@ -571,8 +568,7 @@ private func replace(findStringCall: ApplyInst,
                                                 findStringCall.arguments[1],
                                                 cacheAddr])
 
-  findStringCall.uses.replaceAll(with: newCall, context)
-  context.erase(instruction: findStringCall)
+  findStringCall.replace(with: newCall, context)
 }
 
 private extension GlobalValueInst {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RedundantLoadElimination.swift

@@ -279,8 +279,7 @@ private func replace(load: LoadInst, with availableValues: [AvailableValue], _ c
     //
     newValue = ssaUpdater.getValue(inMiddleOf: load.parentBlock)
   }
-  load.uses.replaceAll(with: newValue, context)
-  context.erase(instruction: load)
+  load.replace(with: newValue, context)
 }
 
 private func provideValue(

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyApply.swift

@@ -56,8 +56,7 @@ private func tryTransformThickToThinCallee(of apply: ApplyInst, _ context: Simpl
                                        isNonThrowing: apply.isNonThrowing,
                                        isNonAsync: apply.isNonAsync,
                                        specializationInfo: apply.specializationInfo)
-    apply.uses.replaceAll(with: newApply, context)
-    context.erase(instruction: apply)
+    apply.replace(with: newApply, context)
     return true
   }
   return false

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBeginAndLoadBorrow.swift

@@ -59,9 +59,8 @@ extension LoadBorrowInst : Simplifyable, SILCombineSimplifyable {
     }
     let builder = Builder(before: self, context)
     let loadCopy = builder.createLoad(fromAddress: address, ownership: .copy)
-    let forwardedOwnedValue = replace(guaranteedValue: self, withOwnedValue: loadCopy, context)
-    copy.uses.replaceAll(with: forwardedOwnedValue, context)
-    context.erase(instruction: copy)
+    let forwardedOwnedValue = replaceGuaranteed(value: self, withOwnedValue: loadCopy, context)
+    copy.replace(with: forwardedOwnedValue, context)
     context.erase(instructionIncludingAllUsers: self)
   }
 }
@@ -118,9 +117,8 @@ private func tryReplaceCopy(
   }
   let builder = Builder(before: beginBorrow, context)
   let copiedOperand = builder.createCopyValue(operand: beginBorrow.borrowedValue)
-  let forwardedOwnedValue = replace(guaranteedValue: beginBorrow, withOwnedValue: copiedOperand, context)
-  copy.uses.replaceAll(with: forwardedOwnedValue, context)
-  context.erase(instruction: copy)
+  let forwardedOwnedValue = replaceGuaranteed(value: beginBorrow, withOwnedValue: copiedOperand, context)
+  copy.replace(with: forwardedOwnedValue, context)
   context.erase(instructionIncludingAllUsers: beginBorrow)
   return true
 }
@@ -140,7 +138,7 @@ private func tryReplaceCopy(
 ///   destroy_value %2
 /// ```
 private func convertAllUsesToOwned(of beginBorrow: BeginBorrowInst, _ context: SimplifyContext) {
-  let forwardedOwnedValue = replace(guaranteedValue: beginBorrow, withOwnedValue: beginBorrow.borrowedValue, context)
+  let forwardedOwnedValue = replaceGuaranteed(value: beginBorrow, withOwnedValue: beginBorrow.borrowedValue, context)
   beginBorrow.borrowedValue.replaceAllDestroys(with: forwardedOwnedValue, context)
   context.erase(instructionIncludingAllUsers: beginBorrow)
 }
@@ -216,29 +214,29 @@ private extension ForwardingInstruction {
 ///
 /// Returns the last owned value in a forwarding-chain or `ownedValue` if `guaranteedValue` has
 /// no forwarding uses.
-private func replace(guaranteedValue: Value, withOwnedValue ownedValue: Value, _ context: SimplifyContext) -> Value {
+private func replaceGuaranteed(value: Value, withOwnedValue ownedValue: Value, _ context: SimplifyContext) -> Value {
   var result = ownedValue
   var numForwardingUses = 0
-  for use in guaranteedValue.uses {
+  for use in value.uses {
 
     switch use.instruction {
     case let tei as TupleExtractInst:
       numForwardingUses += 1
       let dti = Builder(before: tei, context).createDestructureTuple(tuple: ownedValue)
-      result = replace(guaranteedValue: tei, withOwnedValue: dti.results[tei.fieldIndex], context)
+      result = replaceGuaranteed(value: tei, withOwnedValue: dti.results[tei.fieldIndex], context)
       context.erase(instruction: tei)
     case let sei as StructExtractInst:
       numForwardingUses += 1
       let dsi = Builder(before: sei, context).createDestructureStruct(struct: ownedValue)
-      result = replace(guaranteedValue: sei, withOwnedValue: dsi.results[sei.fieldIndex], context)
+      result = replaceGuaranteed(value: sei, withOwnedValue: dsi.results[sei.fieldIndex], context)
       context.erase(instruction: sei)
     case let fwdInst as (SingleValueInstruction & ForwardingInstruction) where
          fwdInst.isSingleForwardedOperand(use):
       // Other forwarding instructions beside tuple_extract and struct_extract
       numForwardingUses += 1
       use.set(to: ownedValue, context)
       fwdInst.setForwardingOwnership(to: .owned, context)
-      result = replace(guaranteedValue: fwdInst, withOwnedValue: fwdInst, context)
+      result = replaceGuaranteed(value: fwdInst, withOwnedValue: fwdInst, context)
     case is EndBorrowInst:
       break
     default:

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBeginCOWMutation.swift

@@ -86,8 +86,7 @@ private extension BeginCOWMutationInst {
 
     for use in buffer.uses.ignoreDebugUses {
       let endCOW = use.instruction as! EndCOWMutationInst
-      endCOW.uses.replaceAll(with: instance, context)
-      context.erase(instruction: endCOW)
+      endCOW.replace(with: instance, context)
     }
     context.erase(instructionIncludingDebugUses: self)
     return true

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBranch.swift

@@ -53,8 +53,7 @@ private extension BranchInst {
       if let phi = Phi(arg),
          let bfi = phi.borrowedFrom
       {
-        bfi.uses.replaceAll(with: op.value, context)
-        context.erase(instruction: bfi)
+        bfi.replace(with: op.value, context)
       } else {
         arg.uses.replaceAll(with: op.value, context)
       }

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -33,9 +33,8 @@ extension BuiltinInst : OnoneSimplifyable {
            .Alignof:
         optimizeTargetTypeConst(context)
       case .DestroyArray:
-        if let elementType = substitutionMap.replacementTypes[0],
-           elementType.isTrivial(in: parentFunction)
-        {
+        let elementType = substitutionMap.replacementType.loweredType(in: parentFunction, maximallyAbstracted: true)
+        if elementType.isTrivial(in: parentFunction) {
           context.erase(instruction: self)
           return
         }
@@ -129,24 +128,18 @@ private extension BuiltinInst {
   }
 
   func optimizeCanBeClass(_ context: SimplifyContext) {
-    guard let ty = substitutionMap.replacementTypes[0] else {
-      return
-    }
     let literal: IntegerLiteralInst
-    switch ty.canBeClass {
-    case .IsNot:
+    switch substitutionMap.replacementType.canonical.canBeClass {
+    case .isNot:
       let builder = Builder(before: self, context)
       literal = builder.createIntegerLiteral(0,  type: type)
-    case .Is:
+    case .is:
       let builder = Builder(before: self, context)
       literal = builder.createIntegerLiteral(1,  type: type)
-    case .CanBe:
+    case .canBe:
       return
-    default:
-      fatalError()
     }
-    uses.replaceAll(with: literal, context)
-    context.erase(instruction: self)
+    self.replace(with: literal, context)
   }
 
   func optimizeAssertConfig(_ context: SimplifyContext) {
@@ -167,10 +160,7 @@ private extension BuiltinInst {
   }
 
   func optimizeTargetTypeConst(_ context: SimplifyContext) {
-    guard let ty = substitutionMap.replacementTypes[0] else {
-      return
-    }
-    
+    let ty = substitutionMap.replacementType.loweredType(in: parentFunction, maximallyAbstracted: true)
     let value: Int?
     switch id {
     case .Sizeof: