Swift SIL: add var Function.instructions

To be used to iterate over all instructions in a function without the need of two loops - one for blocks and one for instructions.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/DataStructures/Set.swift

@@ -150,11 +150,9 @@ struct InstructionSet : CustomStringConvertible, CustomReflectable {
   var description: String {
     let function = NodeSet_getFunction(bridged).function
     var d = "{\n"
-    for block in function.blocks {
-      for inst in block.instructions {
-        if contains(inst) {
-          d += inst.description
-        }
+    for inst in function.instructions {
+      if contains(inst) {
+        d += inst.description
       }
     }
     d += "}\n"

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AssumeSingleThreaded.swift

@@ -29,12 +29,10 @@ import SIL
 
 let assumeSingleThreadedPass = FunctionPass(
   name: "sil-assume-single-threaded", { function, context in
-    for block in function.blocks {
-      for inst in block.instructions {
-        guard let rcInst = inst as? RefCountingInst else { continue }
+    for inst in function.instructions {
+      guard let rcInst = inst as? RefCountingInst else { continue }
 
-        rcInst.setAtomicity(isAtomic: false, context)
-      }
+      rcInst.setAtomicity(isAtomic: false, context)
     }
   }
 )

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/EscapeInfoDumper.swift

@@ -43,24 +43,22 @@ let escapeInfoDumper = FunctionPass(name: "dump-escape-info", {
   }
 
 
-  for block in function.blocks {
-    for inst in block.instructions {
-      if let allocRef = inst as? AllocRefInst {
-        
-        var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: Visitor())
-        let escapes = walker.isEscaping(object: allocRef)
-        let results = walker.visitor.results
-        
-        let res: String
-        if escapes {
-          res = "global"
-        } else if results.isEmpty {
-          res = " -    "
-        } else {
-          res = Array(results).sorted().joined(separator: ",")
-        }
-        print("\(res): \(allocRef)")
+  for inst in function.instructions {
+    if let allocRef = inst as? AllocRefInst {
+      
+      var walker = EscapeInfo(calleeAnalysis: context.calleeAnalysis, visitor: Visitor())
+      let escapes = walker.isEscaping(object: allocRef)
+      let results = walker.visitor.results
+      
+      let res: String
+      if escapes {
+        res = "global"
+      } else if results.isEmpty {
+        res = " -    "
+      } else {
+        res = Array(results).sorted().joined(separator: ",")
       }
+      print("\(res): \(allocRef)")
     }
   }
   print("End function \(function.name)\n")
@@ -81,16 +79,14 @@ let addressEscapeInfoDumper = FunctionPass(name: "dump-addr-escape-info", {
   var valuesToCheck = [Value]()
   var applies = [Instruction]()
 
-  for block in function.blocks {
-    for inst in block.instructions {
-      switch inst {
-        case let fli as FixLifetimeInst:
-          valuesToCheck.append(fli.operand)
-        case is FullApplySite:
-          applies.append(inst)
-        default:
-          break
-      }
+  for inst in function.instructions {
+    switch inst {
+      case let fli as FixLifetimeInst:
+        valuesToCheck.append(fli.operand)
+      case is FullApplySite:
+        applies.append(inst)
+      default:
+        break
     }
   }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjCBridgingOptimization.swift

@@ -48,12 +48,10 @@ let objCBridgingOptimization = FunctionPass(name: "objc-bridging-opt", {
   }
 
   // Now try to optimize non-optional and optional -> non-optional bridging.
-  for block in function.blocks {
-    for inst in block.instructions {
-      if let apply = inst as? ApplyInst {
-        if !optimizeNonOptionalBridging(apply, context) {
-          return
-        }
+  for inst in function.instructions {
+    if let apply = inst as? ApplyInst {
+      if !optimizeNonOptionalBridging(apply, context) {
+        return
       }
     }
   }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/RangeDumper.swift

@@ -25,24 +25,22 @@ let rangeDumper = FunctionPass(name: "dump-ranges", {
   var outs = Stack<Instruction>(context)
   defer { outs.deinitialize() }
 
-  for block in function.blocks {
-    for inst in block.instructions {
-      if let sli = inst as? StringLiteralInst {
-        switch sli.string {
-          case "begin":
-            precondition(begin == nil, "more than one begin instruction")
-            begin = sli
-          case "end":
-            ends.append(sli)
-          case "interior":
-            interiors.append(sli)
-          case "inside":
-            ins.append(sli)
-          case "outside":
-            outs.append(sli)
-          default:
-            break
-        }
+  for inst in function.instructions {
+    if let sli = inst as? StringLiteralInst {
+      switch sli.string {
+        case "begin":
+          precondition(begin == nil, "more than one begin instruction")
+          begin = sli
+        case "end":
+          ends.append(sli)
+        case "interior":
+          interiors.append(sli)
+        case "inside":
+          ins.append(sli)
+        case "outside":
+          outs.append(sli)
+        default:
+          break
       }
     }
   }

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/StackPromotion.swift

@@ -44,23 +44,21 @@ let stackPromotion = FunctionPass(name: "stack-promotion", {
   let deadEndBlocks = context.deadEndBlocks
 
   var changed = false
-  for block in function.blocks {
-    for inst in block.instructions {
-      if let ar = inst as? AllocRefInstBase {
-        if deadEndBlocks.isDeadEnd(block) {
-          // 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
-          // use-after-free problem.
-          continue
-        }
-        if !context.continueWithNextSubpassRun(for: ar) {
-          break
-        }
+  for inst in function.instructions {
+    if let ar = inst as? AllocRefInstBase {
+      if deadEndBlocks.isDeadEnd(ar.block) {
+        // 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
+        // use-after-free problem.
+        continue
+      }
+      if !context.continueWithNextSubpassRun(for: ar) {
+        break
+      }
 
-        if tryPromoteAlloc(ar, deadEndBlocks, context) {
-          changed = true
-        }
+      if tryPromoteAlloc(ar, deadEndBlocks, context) {
+        changed = true
       }
     }
   }

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -41,6 +41,11 @@ final public class Function : CustomStringConvertible, HasShortDescription {
     entryBlock.arguments.lazy.map { $0 as! FunctionArgument }
   }
 
+  /// All instructions of all blocks.
+  public var instructions: LazySequence<FlattenSequence<LazyMapSequence<List<BasicBlock>, List<Instruction>>>> {
+    blocks.lazy.flatMap { $0.instructions }
+  }
+
   public var numIndirectResultArguments: Int {
     SILFunction_numIndirectResultArguments(bridged)
   }