make InstructionRange.contains more efficient

Instead of trying to find an instruction by iterating through all instruction in the list, use an InstructionSet.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -48,40 +48,45 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
 
   private var insertedInsts: InstructionSet
 
+  // For efficiency, this set does not include instructions in blocks which are not the begin or any end block.
+  private var inExclusiveRange: InstructionSet
+
   init(begin beginInst: Instruction, _ context: some Context) {
     self.begin = beginInst
     self.blockRange = BasicBlockRange(begin: beginInst.parentBlock, context)
     self.insertedInsts = InstructionSet(context)
+    self.inExclusiveRange = InstructionSet(context)
+    self.inExclusiveRange.insert(beginInst)
   }
 
   /// Insert a potential end instruction.
   mutating func insert(_ inst: Instruction) {
     insertedInsts.insert(inst)
+    insertIntoRange(instructions: ReverseInstructionList(first: inst.previous))
     blockRange.insert(inst.parentBlock)
+    if inst.parentBlock != begin.parentBlock {
+      // The first time an instruction is inserted in another block than the begin-block we need to insert
+      // instructions from the begin instruction to the end of the begin block.
+      // For subsequent insertions this is a no-op: `insertIntoRange` will return immediately because those
+      // instruction are already inserted.
+      insertIntoRange(instructions: begin.parentBlock.instructions.reversed())
+    }
   }
 
   /// Insert a sequence of potential end instructions.
-  mutating func insert<S: Sequence>(contentsOf other: S) where S.Element == Instruction {
+  mutating func insert<S: Sequence>(contentsOf other: S) where S.Element: Instruction {
     for inst in other {
       insert(inst)
     }
   }
 
   /// Returns true if the exclusive range contains `inst`.
   func contains(_ inst: Instruction) -> Bool {
-    let block = inst.parentBlock
-    if !blockRange.inclusiveRangeContains(block) { return false }
-    var inRange = false
-    if blockRange.contains(block) {
-      if block != blockRange.begin { return true }
-      inRange = true
+    if inExclusiveRange.contains(inst) {
+      return true
     }
-    for i in block.instructions.reversed() {
-      if i == inst { return inRange }
-      if insertedInsts.contains(i) { inRange = true }
-      if i == begin { return false }
-    }
-    fatalError("didn't find instruction in its block")
+    let block = inst.parentBlock
+    return block != begin.parentBlock && blockRange.contains(block)
   }
 
   /// Returns true if the inclusive range contains `inst`.
@@ -129,6 +134,14 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
     }
   }
 
+  private mutating func insertIntoRange(instructions: ReverseInstructionList) {
+    for inst in instructions {
+      if !inExclusiveRange.insert(inst) {
+        return
+      }
+    }
+  }
+
   var description: String {
     return (isValid ? "" : "<invalid>\n") +
       """
@@ -141,6 +154,7 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
 
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
+    inExclusiveRange.deinitialize()
     insertedInsts.deinitialize()
     blockRange.deinitialize()
   }