[AddressLowering] Fix dead argument filtering.

The filterDeadArgs function takes a list of dead argument
indices--ordered from least to greatest--a list of original arguments,
and produces a list of arguments excluding the arguments at those dead
indices.

It does that by iterating from 0 to size(originalArguments) - 1, adding
the original argument at that index to the list of new arguments, so
long as the index that of a dead argument.  To avoid doing lookups into
a set, this relies on the dead arguments being ordered ascending.  There
is an interator into the dead argument list that is incremented only
when the current index is dead.

When that iterator is at the end, dereferencing it just gives the size
of the array of dead arguments.  So in the case where the first argument
is dead but no other arguments are, and there _are_ other arguments, the
first argument would be skipped, and the second argument's index would
be found to be equal to the dereferenced iterator (1).

Previously, there was no check that the iterator was not at the end.
The result was failing to add the second argument to the new list.  And
tripping an assertion failure.

Here, it is checked that the iterator is not at the end.

Author: nate-chandler

lib/SILOptimizer/Mandatory/AddressLowering.cpp

@@ -3409,7 +3409,7 @@ static void filterDeadArgs(OperandValueArrayRef origArgs,
                            SmallVectorImpl<SILValue> &newArgs) {
   auto nextDeadArgI = deadArgIndices.begin();
   for (unsigned i : indices(origArgs)) {
-    if (i == *nextDeadArgI) {
+    if (i == *nextDeadArgI && nextDeadArgI != deadArgIndices.end()) {
       ++nextDeadArgI;
       continue;
     }

test/SILOptimizer/address_lowering_phi.sil

@@ -15,6 +15,8 @@ enum Optional<T> {
   case some(T)
 }
 
+struct S {}
+
 struct SRef<T> {
   @_hasStorage var object: AnyObject { get set }
   @_hasStorage var element: T { get set }
@@ -517,3 +519,20 @@ exit(%self_2 : @owned $Self):
   %retval = tuple ()
   return %retval : $()
 }
+
+// Check deleting the first of multiple block arguments.
+// CHECK-LABEL: sil [ossa] @f110_nonfinal_argument : {{.*}} {
+// CHECK:       bb3({{%[^,]+}} : $S):
+// CHECK-LABEL: } // end sil function 'f110_nonfinal_argument'
+sil [ossa] @f110_nonfinal_argument : $@convention(thin) <T> (@in T, S) -> () {
+entry(%instance : @owned $T, %s : $S):
+  cond_br undef, left, right
+left:
+  br exit(%instance : $T, %s : $S)
+right:
+  br exit(%instance : $T, %s : $S)
+exit(%instance_2 : @owned $T, %s_2 : $S):
+  destroy_value %instance_2 : $T
+  %retval = tuple ()
+  return %retval : $()
+}