Swift SIL: rename parent accessors to parentX, e.g. Instruction.parentBlock

It makes it easier to read

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockRange.swift

@@ -110,7 +110,7 @@ struct BasicBlockRange : CustomStringConvertible, NoReflectionChildren {
 
   /// Returns true if the range is valid and that's iff the begin block dominates all blocks of the range.
   var isValid: Bool {
-    let entry = begin.function.entryBlock
+    let entry = begin.parentFunction.entryBlock
     return begin == entry ||
       // If any block in the range is not dominated by `begin`, the range propagates back to the entry block.
       !inclusiveRangeContains(entry)

SwiftCompilerSources/Sources/Optimizer/DataStructures/FunctionUses.swift

@@ -93,7 +93,7 @@ struct FunctionUses {
         result += "<unknown uses>\n"
       }
       for inst in self {
-        result += "@\(inst.function.name): \(inst)\n"
+        result += "@\(inst.parentFunction.name): \(inst)\n"
 
       }
       result += "]"

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -50,14 +50,14 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
 
   init(begin beginInst: Instruction, _ context: PassContext) {
     self.begin = beginInst
-    self.blockRange = BasicBlockRange(begin: beginInst.block, context)
+    self.blockRange = BasicBlockRange(begin: beginInst.parentBlock, context)
     self.insertedInsts = InstructionSet(context)
   }
 
   /// Insert a potential end instruction.
   mutating func insert(_ inst: Instruction) {
     insertedInsts.insert(inst)
-    blockRange.insert(inst.block)
+    blockRange.insert(inst.parentBlock)
   }
 
   /// Insert a sequence of potential end instructions.
@@ -69,7 +69,7 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
 
   /// Returns true if the exclusive range contains `inst`.
   func contains(_ inst: Instruction) -> Bool {
-    let block = inst.block
+    let block = inst.parentBlock
     if !blockRange.inclusiveRangeContains(block) { return false }
     var inRange = false
     if blockRange.contains(block) {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -144,7 +144,7 @@ func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
   }
 
   // If the function never returns, the argument can not escape to another arg/return.
-  guard let returnInst = arg.function.returnInstruction else {
+  guard let returnInst = arg.parentFunction.returnInstruction else {
     return false
   }
 
@@ -189,7 +189,7 @@ private func isOperandOfRecursiveCall(_ op: Operand) -> Bool {
   let inst = op.instruction
   if let applySite = inst as? FullApplySite,
      let callee = applySite.referencedFunction,
-     callee == inst.function,
+     callee == inst.parentFunction,
      let argIdx = applySite.argumentIndex(of: op),
      op.value == callee.arguments[argIdx] {
     return true
@@ -256,7 +256,7 @@ func isExclusiveEscapeToArgument(fromArgument: Argument, fromPath: SmallProjecti
   }
   let visitor = IsExclusiveArgumentEscapeVisitor(fromArgument: fromArgument, fromPath: fromPath,
                                                  toArgumentIndex: toArgumentIndex, toPath: toPath)
-  let toArg = fromArgument.function.arguments[toArgumentIndex]
+  let toArg = fromArgument.parentFunction.arguments[toArgumentIndex]
   return !toArg.at(toPath).isEscapingWhenWalkingDown(using: visitor, context)
 }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -417,7 +417,7 @@ private struct ArgumentEscapingWalker : ValueDefUseWalker, AddressDefUseWalker {
 
   mutating func leafUse(address: Operand, path: UnusedWalkingPath) -> WalkResult {
     let inst = address.instruction
-    let function = inst.function
+    let function = inst.parentFunction
     switch inst {
     case let copy as CopyAddrInst:
       if address == copy.sourceOperand &&

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjCBridgingOptimization.swift

@@ -144,7 +144,8 @@ private func optimizeNonOptionalBridging(_ apply: ApplyInst,
 
     let originalObjCValue = originalObjCValueSwitch.enumOp
     let optionalReplacement = originalObjCValue.copy(at: originalObjCValueSwitch,
-                                                     andMakeAvailableIn: bridgeToObjcCall.block, context)
+                                                     andMakeAvailableIn: bridgeToObjcCall.parentBlock,
+                                                     context)
     let builder = Builder(at: bridgeToObjcCall, context)
 
     // We know that it's the some-case.
@@ -183,7 +184,7 @@ private func optimizeNonOptionalBridging(_ apply: ApplyInst,
   // Creates a `switch_enum` on `originalObjCValue` and in the nil-case return a bridged
   // empty value.
   // Create the needed blocks of the `switch_enum` CFG diamond.
-  let origBlock = bridgeToSwiftCall.block
+  let origBlock = bridgeToSwiftCall.parentBlock
   let someBlock = context.splitBlock(at: bridgeToSwiftCall)
   let noneBlock = context.splitBlock(at: bridgeToSwiftCall)
   let continueBlock = context.splitBlock(at: bridgeToSwiftCall)
@@ -217,7 +218,7 @@ private func optimizeNonOptionalBridging(_ apply: ApplyInst,
   let s = continueBlock.addBlockArgument(type: objCType, ownership: .owned, context)
 
   // Now replace the bridged value with the original value in the destination block.
-  let replacement = s.makeAvailable(in: bridgeToObjcCall.block, context)
+  let replacement = s.makeAvailable(in: bridgeToObjcCall.parentBlock, context)
   bridgeToObjcCall.uses.replaceAll(with: replacement, context)
   context.erase(instruction: bridgeToObjcCall)
   return true
@@ -315,9 +316,9 @@ private func isOptionalBridging(of value: Value, isBridging: (Value) -> ApplyIns
     } else {
       // The none-case
       if noneSwitch != nil { return nil }
-      guard let singlePred = enumInst.block.singlePredecessor,
+      guard let singlePred = enumInst.parentBlock.singlePredecessor,
             let se = singlePred.terminator as? SwitchEnumInst,
-            se.getUniqueSuccessor(forCaseIndex: enumInst.caseIndex) === enumInst.block else {
+            se.getUniqueSuccessor(forCaseIndex: enumInst.caseIndex) === enumInst.parentBlock else {
         return nil
       }
       noneSwitch = se
@@ -335,9 +336,9 @@ private func isOptionalBridging(of value: Value, isBridging: (Value) -> ApplyIns
 /// the payload block argument of the `switch_enum`.
 private func isPayloadOfSwitchEnum(_ value: Value) -> (SwitchEnumInst, case: Int)? {
   if let payloadArg = value as? BlockArgument,
-     let pred = payloadArg.block.singlePredecessor,
+     let pred = payloadArg.parentBlock.singlePredecessor,
      let se = pred.terminator as? SwitchEnumInst,
-     let caseIdx = se.getUniqueCase(forSuccessor: payloadArg.block) {
+     let caseIdx = se.getUniqueCase(forSuccessor: payloadArg.parentBlock) {
     return (se, caseIdx)
   }
   return nil

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StackPromotion.swift

@@ -46,7 +46,7 @@ let stackPromotion = FunctionPass(name: "stack-promotion", {
   var changed = false
   for inst in function.instructions {
     if let ar = inst as? AllocRefInstBase {
-      if deadEndBlocks.isDeadEnd(ar.block) {
+      if deadEndBlocks.isDeadEnd(ar.parentBlock) {
         // Don't stack promote any allocation inside a code region which ends up
         // in a no-return block. Such allocations may missing their final release.
         // We would insert the deallocation too early, which may result in a
@@ -170,7 +170,7 @@ func tryPromoteAlloc(_ allocRef: AllocRefInstBase,
   // Do the transformation!
   // Insert `dealloc_stack_ref` instructions at the exit- and end-points of the inner liferange.
   for exitInst in innerRange.exits {
-    if !deadEndBlocks.isDeadEnd(exitInst.block) {
+    if !deadEndBlocks.isDeadEnd(exitInst.parentBlock) {
       let builder = Builder(at: exitInst, context)
       builder.createDeallocStackRef(allocRef)
     }
@@ -197,15 +197,15 @@ private func getDominatingBlockOfAllUsePoints(context: PassContext,
     var result: BasicBlock
     let domTree: DominatorTree
     mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
-      let defBlock = operand.value.definingBlock
+      let defBlock = operand.value.parentBlock
       if defBlock.dominates(result, domTree) {
         result = defBlock
       }
       return .continueWalk
     }
   }
 
-  return value.visit(using: FindDominatingBlock(result: value.block, domTree: domTree), context)!
+  return value.visit(using: FindDominatingBlock(result: value.parentBlock, domTree: domTree), context)!
 }
 
 
@@ -229,13 +229,13 @@ func computeInnerAndOuterLiferanges(instruction: SingleValueInstruction, in domB
 
     mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
       let user = operand.instruction
-      if innerRange.blockRange.begin.dominates(user.block, domTree) {
+      if innerRange.blockRange.begin.dominates(user.parentBlock, domTree) {
         innerRange.insert(user)
       }
-      outerBlockRange.insert(user.block)
+      outerBlockRange.insert(user.parentBlock)
 
       let val = operand.value
-      let defBlock = val.definingBlock
+      let defBlock = val.parentBlock
 
       // Also insert the operand's definition. Otherwise we would miss allocation
       // instructions (for which the `visitUse` closure is not called).

SwiftCompilerSources/Sources/Optimizer/InstructionPasses/SimplifyStrongRetainRelease.swift

@@ -83,11 +83,11 @@ private func isNotReferenceCounted(value: Value, context: PassContext) -> Bool {
       // Note that the `simplifyGlobalValuePass` pass is deleting balanced
       // retains/releases, which doesn't require a Swift 5.1 minimum deployment
       // target.
-      return gvi.function.isSwift51RuntimeAvailable
+      return gvi.parentFunction.isSwift51RuntimeAvailable
     case let rptr as RawPointerToRefInst:
       // Like `global_value` but for the empty collection singletons from the
       // stdlib, e.g. the empty Array singleton.
-      if rptr.function.isSwift51RuntimeAvailable {
+      if rptr.parentFunction.isSwift51RuntimeAvailable {
         // The pattern generated for empty collection singletons is:
         //     %0 = global_addr @_swiftEmptyArrayStorage
         //     %1 = address_to_pointer %0

SwiftCompilerSources/Sources/Optimizer/ModulePasses/StackProtection.swift

@@ -244,7 +244,7 @@ private struct StackProtectionOptimization {
     }
 
     while let arg = worklist.pop() {
-      let f = arg.function
+      let f = arg.parentFunction
       let uses = functionUses.getUses(of: f)
       if uses.hasUnknownUses && enableMoveInout {
         return NeedInsertMoves.yes
@@ -271,9 +271,9 @@ private struct StackProtectionOptimization {
             // It's an indirect argument.
             switch callerArg.accessBase.isStackAllocated {
             case .yes:
-              if !callerArg.function.needsStackProtection {
-                log("alloc_stack in caller: \(callerArg.function.name) -- \(callerArg)")
-                newFunctions.push(callerArg.function)
+              if !callerArg.parentFunction.needsStackProtection {
+                log("alloc_stack in caller: \(callerArg.parentFunction.name) -- \(callerArg)")
+                newFunctions.push(callerArg.parentFunction)
               }
             case .no:
               break
@@ -291,10 +291,10 @@ private struct StackProtectionOptimization {
               if foundUnknownRoots && enableMoveInout {
                 return NeedInsertMoves.yes
               }
-              if foundStackAlloc && !obj.function.needsStackProtection {
+              if foundStackAlloc && !obj.parentFunction.needsStackProtection {
                 // The object is created by an `alloc_ref [stack]`.
-                log("object in caller: \(obj.function.name) -- \(obj)")
-                newFunctions.push(obj.function)
+                log("object in caller: \(obj.parentFunction.name) -- \(obj)")
+                newFunctions.push(obj.parentFunction)
               }
             case .unknown:
               if enableMoveInout {
@@ -308,10 +308,10 @@ private struct StackProtectionOptimization {
             if foundUnknownRoots && enableMoveInout {
               return NeedInsertMoves.yes
             }
-            if foundStackAlloc && !callerArg.function.needsStackProtection {
+            if foundStackAlloc && !callerArg.parentFunction.needsStackProtection {
               // The object is created by an `alloc_ref [stack]`.
-              log("object arg in caller: \(callerArg.function.name) -- \(callerArg)")
-              newFunctions.push(callerArg.function)
+              log("object arg in caller: \(callerArg.parentFunction.name) -- \(callerArg)")
+              newFunctions.push(callerArg.parentFunction)
             }
           }
         }
@@ -330,7 +330,7 @@ private struct StackProtectionOptimization {
       return
     }
 
-    let function = argument.function
+    let function = argument.parentFunction
     let entryBlock = function.entryBlock
     let loc = entryBlock.instructions.first!.location.autoGenerated
     let builder = Builder(atBeginOf: entryBlock, location: loc, context)
@@ -376,9 +376,9 @@ private struct StackProtectionOptimization {
     }
 
     builder.createCopyAddr(from: beginAccess, to: temporary, takeSource: true, initializeDest: true)
-    log("move object protection in \(beginAccess.function.name): \(beginAccess)")
+    log("move object protection in \(beginAccess.parentFunction.name): \(beginAccess)")
 
-    beginAccess.function.setNeedsStackProtection(context)
+    beginAccess.parentFunction.setNeedsStackProtection(context)
 
     // Access scopes are not necessarily properly nested, which can result in
     // not properly nested stack allocations.

SwiftCompilerSources/Sources/Optimizer/PassManager/PassContext.swift

@@ -164,7 +164,7 @@ extension Builder {
     if let nextInst = insPnt.next {
       self.init(insertAt: .before(nextInst), location: location, passContext: context._bridged)
     } else {
-      self.init(insertAt: .atEndOf(insPnt.block), location: location, passContext: context._bridged)
+      self.init(insertAt: .atEndOf(insPnt.parentBlock), location: location, passContext: context._bridged)
     }
   }
 

SwiftCompilerSources/Sources/Optimizer/TestPasses/AccessDumper.swift

@@ -91,6 +91,6 @@ private func checkAliasInfo(forArgumentsOf apply: ApplyInst, expectDistinct: Boo
   }
 
   print("in function")
-  print(apply.function)
+  print(apply.parentFunction)
   fatalError()
 }

SwiftCompilerSources/Sources/Optimizer/TestPasses/RangeDumper.swift

@@ -88,7 +88,7 @@ private func verify(_ blockRange: BasicBlockRange, _ context: PassContext) {
     inInclusiveRange.insert(b)
   }
 
-  for b in blockRange.begin.function.blocks {
+  for b in blockRange.begin.parentFunction.blocks {
     assert(blockRange.contains(b) == inRange.contains(b))
     assert(blockRange.inclusiveRangeContains(b) == inInclusiveRange.contains(b))
   }

SwiftCompilerSources/Sources/Optimizer/TestPasses/TestInstructionIteration.swift

@@ -55,11 +55,11 @@ private func handle(instruction: Instruction, _ context: PassContext) {
   if let sl = instruction as? StringLiteralInst {
     switch sl.string {
       case "delete_strings":
-        deleteAllInstructions(ofType: StringLiteralInst.self, in: instruction.block, context)
+        deleteAllInstructions(ofType: StringLiteralInst.self, in: instruction.parentBlock, context)
       case "delete_ints":
-        deleteAllInstructions(ofType: IntegerLiteralInst.self, in: instruction.block, context)
+        deleteAllInstructions(ofType: IntegerLiteralInst.self, in: instruction.parentBlock, context)
       case "delete_branches":
-        deleteAllInstructions(ofType: BranchInst.self, in: instruction.block, context)
+        deleteAllInstructions(ofType: BranchInst.self, in: instruction.parentBlock, context)
       case "split_block":
         _ = context.splitBlock(at: instruction)
       default:

SwiftCompilerSources/Sources/Optimizer/Utilities/AccessUtils.swift

@@ -86,7 +86,7 @@ enum AccessBase : CustomStringConvertible, Hashable {
     case let arg as FunctionArgument     : self = .argument(arg)
     case let ga as GlobalAddrInst        : self = .global(ga.global)
     case let mvr as MultipleValueInstructionResult:
-      if let ba = mvr.instruction as? BeginApplyInst, baseAddress.type.isAddress {
+      if let ba = mvr.parentInstruction as? BeginApplyInst, baseAddress.type.isAddress {
         self = .yield(ba)
       } else {
         self = .unidentified

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -734,7 +734,7 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
     case is AllocBoxInst:
       return cachedWalkDown(addressOrValue: def, path: path.with(knownType: nil))
     case let arg as BlockArgument:
-      let block = arg.block
+      let block = arg.parentBlock
       switch block.singlePredecessor!.terminator {
       case let ta as TryApplyInst:
         if block != ta.normalBlock { return isEscaping }

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -22,7 +22,7 @@ extension Builder {
   static func insert(after inst: Instruction, location: Location,
                      _ context: PassContext, insertFunc: (Builder) -> ()) {
     if inst is TermInst {
-      for succ in inst.block.successors {
+      for succ in inst.parentBlock.successors {
         assert(succ.hasSinglePredecessor,
                "the terminator instruction must not have critical successors")
         let builder = Builder(at: succ.instructions.first!, location: location,
@@ -47,7 +47,7 @@ extension Value {
     assert(uses.isEmpty)
     assert(ownership == .owned)
 
-    let beginBlock = definingBlock
+    let beginBlock = parentBlock
     var useToDefRange = BasicBlockRange(begin: beginBlock, context)
     defer { useToDefRange.deinitialize() }
 

SwiftCompilerSources/Sources/Optimizer/Utilities/WalkUtils.swift

@@ -374,7 +374,7 @@ extension ValueDefUseWalker {
          let payload = succBlock.arguments.first {
         return walkDownUses(ofValue: payload, path: path)
       } else if path.popIfMatches(.anyValueFields, index: nil) != nil {
-        for succBlock in se.block.successors {
+        for succBlock in se.parentBlock.successors {
           if let payload = succBlock.arguments.first,
              walkDownUses(ofValue: payload, path: path) == .abortWalk {
             return .abortWalk
@@ -597,7 +597,7 @@ extension ValueUseDefWalker {
     case let ued as UncheckedEnumDataInst:
       return walkUp(value: ued.operand, path: path.push(.enumCase, index: ued.caseIndex))
     case let mvr as MultipleValueInstructionResult:
-      let instruction = mvr.instruction
+      let instruction = mvr.parentInstruction
       if let ds = instruction as? DestructureStructInst {
         return walkUp(value: ds.operand, path: path.push(.structField, index: mvr.index))
       } else if let dt = instruction as? DestructureTupleInst {
@@ -625,7 +625,7 @@ extension ValueUseDefWalker {
         return .continueWalk
       }
 
-      let block = arg.block
+      let block = arg.parentBlock
       if let pred = block.singlePredecessor,
          let se = pred.terminator as? SwitchEnumInst,
          let caseIdx = se.getUniqueCase(forSuccessor: block) {