Optimizer: Fix InstructionRange's begin instruction

Just don't store the begin instruction.
This led to problem if the "begin" was not actually an instruction but a block argument.
Using the first instruction of that block is not correct in case the range ends immediately at the first instruction, e.g.

```
  bb0(%0 : @owned $C):
    destroy_value %0
```

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -40,9 +40,6 @@ import SIL
 /// destruct this data structure, e.g. in a `defer {}` block.
 struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
 
-  /// The dominating begin instruction.
-  let begin: Instruction
-  
   /// The underlying block range.
   private(set) var blockRange: BasicBlockRange
 
@@ -52,36 +49,37 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
   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 = InstructionRange(beginBlock: beginInst.parentBlock, context)
     self.inExclusiveRange.insert(beginInst)
   }
 
   init(for value: Value, _ context: some Context) {
-    self = InstructionRange(begin: InstructionRange.beginningInstruction(for: value), context)
+    if let inst = value.definingInstruction {
+      self = InstructionRange(begin: inst, context)
+    } else if let arg = value as? Argument {
+      self = InstructionRange(beginBlock: arg.parentBlock, context)
+    } else {
+      fatalError("cannot build an instruction range for \(value)")
+    }
   }
 
-  static func beginningInstruction(for value: Value) -> Instruction {
-    if let def = value.definingInstructionOrTerminator {
-      return def
-    }
-    assert(Phi(value) != nil || value is FunctionArgument)
-    return value.parentBlock.instructions.first!
+  private init(beginBlock: BasicBlock, _ context: some Context) {
+    self.blockRange = BasicBlockRange(begin: beginBlock, context)
+    self.insertedInsts = InstructionSet(context)
+    self.inExclusiveRange = InstructionSet(context)
   }
 
   /// 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 {
+    if inst.parentBlock != blockRange.begin {
       // 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())
+      insertIntoRange(instructions: blockRange.begin.instructions.reversed())
     }
   }
 
@@ -98,22 +96,14 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
       return true
     }
     let block = inst.parentBlock
-    return block != begin.parentBlock && blockRange.contains(block)
+    return block != blockRange.begin && blockRange.contains(block)
   }
 
   /// Returns true if the inclusive range contains `inst`.
   func inclusiveRangeContains (_ inst: Instruction) -> Bool {
     contains(inst) || insertedInsts.contains(inst)
   }
 
-  /// Returns true if the range is valid and that's iff the begin instruction
-  /// dominates all instructions of the range.
-  var isValid: Bool {
-    blockRange.isValid &&
-    // Check if there are any inserted instructions before the begin instruction in its block.
-    !ReverseInstructionList(first: begin).dropFirst().contains { insertedInsts.contains($0) }
-  }
-
   /// Returns the end instructions.
   ///
   /// Warning: this returns `begin` if no instructions were inserted.
@@ -155,6 +145,10 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
     }
   }
 
+  var begin: Instruction? {
+    blockRange.begin.instructions.first(where: inExclusiveRange.contains)
+  }
+
   private mutating func insertIntoRange(instructions: ReverseInstructionList) {
     for inst in instructions {
       if !inExclusiveRange.insert(inst) {
@@ -164,9 +158,9 @@ struct InstructionRange : CustomStringConvertible, NoReflectionChildren {
   }
 
   var description: String {
-    return (isValid ? "" : "<invalid>\n") +
+    return (blockRange.isValid ? "" : "<invalid>\n") +
       """
-      begin:    \(begin)
+      begin:    \(begin?.description ?? blockRange.begin.name)
       ends:     \(ends.map { $0.description }.joined(separator: "\n          "))
       exits:    \(exits.map { $0.description }.joined(separator: "\n          "))
       interiors:\(interiors.map { $0.description }.joined(separator: "\n          "))

SwiftCompilerSources/Sources/Optimizer/Utilities/OwnershipLiveness.swift

@@ -913,7 +913,7 @@ struct LivenessBoundary : CustomStringConvertible {
 
   // Compute the boundary of a singly-defined range.
   init(value: Value, range: InstructionRange, _ context: Context) {
-    assert(range.isValid)
+    assert(range.blockRange.isValid)
 
     lastUsers = Stack<Instruction>(context)
     boundaryEdges = Stack<BasicBlock>(context)

test/SILOptimizer/lifetime_dependence/lifetime_dependence_util.sil

@@ -157,7 +157,7 @@ entry(%0 : @owned $C, %1 : @owned $D, %2 : @guaranteed $D, %3 : $*D, %4 : $*D):
 // CHECK-LABEL: dependence_scope: lifetime_dependence_scope with: %inguaranteed_arg_mark
 // CHECK-NEXT: Initialized: %3 = argument of bb0 : $*D
 // CHECK-NEXT: Dependent:   %{{.*}} = mark_dependence [nonescaping] %{{.*}} : $C on %3 : $*D
-// CHECK-NEXT: begin:      %{{.*}} = move_value %{{.*}} : $D
+// CHECK-NEXT: begin:      bb0
 // CHECK-NEXT: ends:     
 // CHECK: dependence_scope: lifetime_dependence_scope with: %inguaranteed_arg_mark
 

test/SILOptimizer/ownership_liveness_unit.sil

@@ -433,7 +433,7 @@ bb0(%0 : $*D, %1 : @guaranteed $D):
 
 // CHECK-LABEL: begin running test 2 of 2 on testInteriorDropDeinit: interior_liveness_swift with: %0
 // CHECK: Interior liveness: %0 = argument of bb0 : $NCInt
-// CHECK-NEXT: begin:      [[DD:%.*]] = drop_deinit %0 : $NCInt
+// CHECK-NEXT: begin:      bb0
 // CHECK-NEXT: ends:       [[DD]] = drop_deinit %0 : $NCInt
 // CHECK-NEXT: exits:
 // CHECK-NEXT: interiors:
@@ -1122,7 +1122,7 @@ bb4(%inner4 : @guaranteed $D):
 
 // CHECK-LABEL: testInnerNonAdjacentReborrow: interior_liveness_swift with: %outer3
 // CHECK: Interior liveness: %{{.*}} = argument of bb3 : $D
-// CHECK-NEXT: begin:      {{.*}} borrowed {{.*}} from
+// CHECK-NEXT: begin:      bb3
 // CHECK-NEXT: ends:
 // CHECK-NEXT: exits:
 // CHECK-NEXT: interiors:

test/SILOptimizer/ranges.sil

@@ -129,22 +129,3 @@ bb3:
   return %r : $()
 }
 
-// CHECK-LABEL:Instruction range in valid_blocks_invalid_instructions:
-// CHECK-NEXT: <invalid>
-// CHECK:      Block range in valid_blocks_invalid_instructions:
-// CHECK-NEXT: begin:     bb0
-// CHECK-NEXT: range:     []
-// CHECK-NEXT: inclrange: [bb0]
-// CHECK-NEXT: ends:      [bb0]
-// CHECK-NEXT: exits:     []
-// CHECK-NEXT: interiors: []
-// CHECK-NEXT: End function valid_blocks_invalid_instructions
-sil @valid_blocks_invalid_instructions : $@convention(thin) () -> () {
-bb0:
-  %0 = string_literal utf8 "end"
-  %1 = string_literal utf8 "begin"
-  %2 = string_literal utf8 "end"
-  %r = tuple()
-  return %r : $()
-}
-