[+0-all-args] Change emitBindOptional to use a switch_enum instead of a select_enum.

Author: gottesmm

lib/SILGen/SILGenExpr.cpp

@@ -4896,24 +4896,32 @@ RValue RValueEmitter::visitAssignExpr(AssignExpr *E, SGFContext C) {
   return SGF.emitEmptyTupleRValue(E, C);
 }
 
-void SILGenFunction::emitBindOptional(SILLocation loc,
-                                      ManagedValue optionalAddrOrValue,
+void SILGenFunction::emitBindOptional(SILLocation loc, ManagedValue optValue,
                                       unsigned depth) {
   assert(depth < BindOptionalFailureDests.size());
   auto failureDest = BindOptionalFailureDests[BindOptionalFailureDests.size()
                                                 - depth - 1];
 
-  // Check whether the optional has a value.
   SILBasicBlock *hasValueBB = createBasicBlock();
-  auto hasValue =
-      emitDoesOptionalHaveValue(loc, optionalAddrOrValue.getValue());
-
+  SILBasicBlock *hasNoValueBB = createBasicBlock();
+
+  // We make a copy to ensure that we pass the value into the
+  // switch_enum at plus 1. This is important since emitBindOptional
+  // does not consume its argument. Additionally, we need to make sure
+  // to create the switch enum builder /after/ emitting the block for
+  // cleanups lest we emit an extra destroy in the .none block.
+  SwitchEnumBuilder SEB(B, loc, optValue.copy(*this, loc));
+  SEB.addOptionalSomeCase(hasValueBB);
   // If not, thread out through a bunch of cleanups.
-  SILBasicBlock *hasNoValueBB = Cleanups.emitBlockForCleanups(failureDest, loc);
-  B.createCondBranch(loc, hasValue, hasValueBB, hasNoValueBB);
-  
-  // If so, continue.
-  B.emitBlock(hasValueBB);
+  SEB.addOptionalNoneCase(hasNoValueBB, failureDest,
+                          [&](ManagedValue mv, SwitchCaseFullExpr &&expr) {
+                            expr.exitAndBranch(loc);
+                          });
+  std::move(SEB).emit();
+
+  // Reset the insertion point at the end of hasValueBB so we can
+  // continue to emit code there.
+  B.setInsertionPoint(hasValueBB);
 }
 
 RValue RValueEmitter::visitBindOptionalExpr(BindOptionalExpr *E, SGFContext C) {

test/SILGen/force_cast_chained_optional.swift

@@ -17,13 +17,12 @@ class D: C {}
 // CHECK: bb0([[ARG:%.*]] : @owned $Foo):
 // CHECK:   [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
 // CHECK:   class_method [[BORROWED_ARG]] : $Foo, #Foo.bar!getter.1 : (Foo) -> () -> Bar?, $@convention(method) (@guaranteed Foo) ->
-// CHECK:   select_enum_addr
-// CHECK:   cond_br {{%.*}}, [[SOME_BAR:bb[0-9]+]], [[NO_BAR:bb[0-9]+]]
+// CHECK:   switch_enum {{%.*}}, case #Optional.some!enumelt.1: [[SOME_BAR:bb[0-9]+]], case #Optional.none!enumelt: [[NO_BAR:bb[0-9]+]]
 //
 // CHECK: [[NO_BAR]]:
 // CHECK:   br [[TRAP:bb[0-9]+]]
 //
-// CHECK: [[SOME_BAR]]:
+// CHECK: [[SOME_BAR]](
 // CHECK:   [[PAYLOAD_ADDR:%.*]] = unchecked_take_enum_data_addr {{%.*}} : $*Optional<Bar>
 // CHECK:   [[BAR:%.*]] = load [copy] [[PAYLOAD_ADDR]]
 // CHECK:   [[BORROWED_BAR:%.*]] = begin_borrow [[BAR]]

test/SILGen/implicitly_unwrapped_optional.swift

@@ -15,11 +15,14 @@ func foo(f f: (() -> ())!) {
 // CHECK:   store [[T0_COPY]] to [init] [[PF]]
 // CHECK:   end_borrow [[BORROWED_T0]] from [[T0]]
 // CHECK:   [[READ:%.*]] = begin_access [read] [unknown] [[PF]] : $*Optional<@callee_guaranteed () -> ()>
-// CHECK:   [[T1:%.*]] = select_enum_addr [[READ]]
-// CHECK:   cond_br [[T1]], bb2, bb1
+// CHECK:   [[READ_TEMP:%.*]] = alloc_stack $Optional<@callee_guaranteed () -> ()>
+// CHECK:   copy_addr [[READ]] to [initialization] [[READ_TEMP]]
+// CHECK:   [[SWITCH_VALUE:%.*]] = load [take] [[READ_TEMP]]
+// CHECK:   switch_enum [[SWITCH_VALUE]] : ${{.*}}, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb1
 //   If it does, project and load the value out of the implicitly unwrapped
 //   optional...
-// CHECK:    bb2:
+// CHECK:    bb2([[SOME_ARG:%.*]] :
+// CHECK-NEXT: destroy_value [[SOME_ARG]]
 // CHECK-NEXT: [[FN0_ADDR:%.*]] = unchecked_take_enum_data_addr [[READ]]
 // CHECK-NEXT: [[FN0:%.*]] = load [copy] [[FN0_ADDR]]
 //   .... then call it
@@ -51,8 +54,8 @@ func wrap_then_unwrap<T>(x x: T) -> T {
 // CHECK-LABEL: sil hidden @$S29implicitly_unwrapped_optional10tuple_bind1xSSSgSi_SStSg_tF : $@convention(thin) (@owned Optional<(Int, String)>) -> @owned Optional<String> {
 func tuple_bind(x x: (Int, String)!) -> String? {
   return x?.1
-  // CHECK:   cond_br {{%.*}}, [[NONNULL:bb[0-9]+]], [[NULL:bb[0-9]+]]
-  // CHECK: [[NONNULL]]:
+  // CHECK:   switch_enum {{%.*}}, case #Optional.some!enumelt.1: [[NONNULL:bb[0-9]+]], case #Optional.none!enumelt: [[NULL:bb[0-9]+]]
+  // CHECK: [[NONNULL]](
   // CHECK:   [[STRING:%.*]] = tuple_extract {{%.*}} : $(Int, String), 1
   // CHECK-NOT: destroy_value [[STRING]]
 }

test/SILGen/load_from_lvalue_in_plus_zero_context.swift

@@ -19,9 +19,12 @@ struct C {
 func test(a: A) {
   let s: String?
   // CHECK:   [[C_TEMP:%.*]] = alloc_stack $Optional<C>
-  // CHECK:   [[TAG:%.*]] = select_enum_addr [[C_TEMP]]
-  // CHECK:   cond_br [[TAG]], [[SOME:bb[0-9]+]], [[NONE:bb[0-9]+]]
-  // CHECK: [[SOME]]:
+  // CHECK:   [[C_TEMP_TEMP:%.*]] = alloc_stack $Optional<C>
+  // CHECK:   copy_addr [[C_TEMP]] to [initialization] [[C_TEMP_TEMP]]
+  // CHECK:   [[C_TEMP_TEMP_LOADED:%.*]] = load [take] [[C_TEMP_TEMP]]
+  // CHECK:   switch_enum [[C_TEMP_TEMP_LOADED]] : $Optional<C>, case #Optional.some!enumelt.1: [[SOME:bb[0-9]+]], case #Optional.none!enumelt: [[NONE:bb[0-9]+]]
+  //
+  // CHECK: [[SOME]](
   // CHECK:   [[C_PAYLOAD:%.*]] = unchecked_take_enum_data_addr [[C_TEMP]]
   // -- This must be a copy, since we'll immediately destroy the value in the
   //    temp buffer

test/SILGen/optional-cast.swift

@@ -12,15 +12,16 @@ class B : A {}
 //   Check whether the temporary holds a value.
 // CHECK:      [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
 // CHECK:      [[ARG_COPY:%.*]] = copy_value [[BORROWED_ARG]]
-// CHECK:      [[T1:%.*]] = select_enum [[ARG_COPY]]
-// CHECK-NEXT: cond_br [[T1]], [[IS_PRESENT:bb.*]], [[NOT_PRESENT:bb[0-9]+]]
+// CHECK:      [[ARG_COPY_COPY:%.*]] = copy_value [[ARG_COPY]]
+// CHECK:      switch_enum [[ARG_COPY_COPY]] : $Optional<A>, case #Optional.some!enumelt.1: [[IS_PRESENT:bb[0-9]+]], case #Optional.none!enumelt: [[NOT_PRESENT:bb[0-9]+]]
 //
 // CHECK:    [[NOT_PRESENT]]:
 // CHECK:      end_borrow [[BORROWED_ARG]] from [[ARG]]
 // CHECK:      br [[NOT_PRESENT_FINISH:bb[0-9]+]]
 //
 //   If so, pull the value out and check whether it's a B.
-// CHECK:    [[IS_PRESENT]]:
+// CHECK:    [[IS_PRESENT]]([[IS_PRESENT_ARG:%.*]] :
+// CHECK-NEXT: destroy_value [[IS_PRESENT_ARG]]
 // CHECK-NEXT: [[VAL:%.*]] = unchecked_enum_data [[ARG_COPY]] : $Optional<A>, #Optional.some!enumelt.1
 // CHECK-NEXT: [[X_VALUE:%.*]] = init_enum_data_addr [[PB]] : $*Optional<B>, #Optional.some
 // CHECK-NEXT: checked_cast_br [[VAL]] : $A to $B, [[IS_B:bb.*]], [[NOT_B:bb[0-9]+]]
@@ -64,45 +65,49 @@ func foo(_ y : A?) {
 // -- Check for some(...)
 // CHECK-NEXT: [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
 // CHECK-NEXT: [[ARG_COPY:%.*]] = copy_value [[BORROWED_ARG]]
-// CHECK:      [[T1:%.*]] = select_enum [[ARG_COPY]]
-// CHECK-NEXT: cond_br [[T1]], [[P:bb.*]], [[NIL_DEPTH_1:bb[0-9]+]]
+// CHECK-NEXT: [[ARG_COPY_COPY:%.*]] = copy_value [[ARG_COPY]]
+// CHECK-NEXT: switch_enum [[ARG_COPY_COPY]] : ${{.*}}, case #Optional.some!enumelt.1: [[P:bb[0-9]+]], case #Optional.none!enumelt: [[NIL_DEPTH_1:bb[0-9]+]]
 //
 // CHECK: [[NIL_DEPTH_1]]:
 // CHECK:   end_borrow [[BORROWED_ARG]] from [[ARG]]
 // CHECK:   br [[FINISH_NIL_0:bb[0-9]+]]
 //
 //   If so, drill down another level and check for some(some(...)).
-// CHECK:    [[P]]:
+// CHECK:    [[P]]([[P_ARG:%.*]] :
+// CHECK-NEXT: destroy_value [[P_ARG]]
 // CHECK-NEXT: [[VALUE_OOOA:%.*]] = unchecked_enum_data [[ARG_COPY]]
-// CHECK:      [[T1:%.*]] = select_enum [[VALUE_OOOA]]
-// CHECK-NEXT: cond_br [[T1]], [[PP:bb.*]], [[NIL_DEPTH_2:bb[0-9]+]]
+// CHECK-NEXT: [[VALUE_OOOA_COPY:%.*]] = copy_value [[VALUE_OOOA]]
+// CHECK-NEXT: switch_enum [[VALUE_OOOA_COPY]] : ${{.*}}, case #Optional.some!enumelt.1: [[PP:bb[0-9]+]], case #Optional.none!enumelt: [[NIL_DEPTH_2:bb[0-9]+]]
 //
 // CHECK: [[NIL_DEPTH_2]]:
 // CHECK:   end_borrow [[BORROWED_ARG]] from [[ARG]]
 // CHECK:   br [[FINISH_NIL_0]]
 //
 //   If so, drill down another level and check for some(some(some(...))).
-// CHECK:    [[PP]]:
+// CHECK:    [[PP]]([[PP_ARG:%.*]] :
+// CHECK-NEXT: destroy_value [[PP_ARG]]
 // CHECK-NEXT: [[VALUE_OOA:%.*]] = unchecked_enum_data [[VALUE_OOOA]]
-// CHECK:      [[T1:%.*]] = select_enum [[VALUE_OOA]]
-// CHECK-NEXT: cond_br [[T1]], [[PPP:bb.*]], [[NIL_DEPTH_3:bb[0-9]+]]
+// CHECK-NEXT: [[VALUE_OOA_COPY:%.*]] = copy_value [[VALUE_OOA]]
+// CHECK-NEXT: switch_enum [[VALUE_OOA_COPY]] : ${{.*}}, case #Optional.some!enumelt.1: [[PPP:bb[0-9]+]], case #Optional.none!enumelt: [[NIL_DEPTH_3:bb[0-9]+]]
 //
 // CHECK: [[NIL_DEPTH_3]]:
 // CHECK:   end_borrow [[BORROWED_ARG]] from [[ARG]]
 // CHECK:   br [[FINISH_NIL_1:bb[0-9]+]]
 //
 //   If so, drill down another level and check for some(some(some(some(...)))).
-// CHECK:    [[PPP]]:
+// CHECK:    [[PPP]]([[PPP_ARG:%.*]] :
+// CHECK-NEXT: destroy_value [[PPP_ARG]]
 // CHECK-NEXT: [[VALUE_OA:%.*]] = unchecked_enum_data [[VALUE_OOA]]
-// CHECK:      [[T1:%.*]] = select_enum [[VALUE_OA]]
-// CHECK-NEXT: cond_br [[T1]], [[PPPP:bb.*]], [[NIL_DEPTH_4:bb[0-9]+]]
+// CHECK-NEXT: [[VALUE_OA_COPY:%.*]] = copy_value [[VALUE_OA]]
+// CHECK-NEXT: switch_enum [[VALUE_OA_COPY]] : ${{.*}}, case #Optional.some!enumelt.1: [[PPPP:bb[0-9]+]], case #Optional.none!enumelt: [[NIL_DEPTH_4:bb[0-9]+]]
 //
 // CHECK: [[NIL_DEPTH_4]]:
 // CHECK:   end_borrow [[BORROWED_ARG]] from [[ARG]]
 // CHECK:   br [[FINISH_NIL_2:bb[0-9]+]]
 //
 //   If so, pull out the A and check whether it's a B.
-// CHECK:    [[PPPP]]:
+// CHECK:    [[PPPP]]([[PPPP_ARG:%.*]] :
+// CHECK-NEXT: destroy_value [[PPPP_ARG]]
 // CHECK-NEXT: [[VAL:%.*]] = unchecked_enum_data [[VALUE_OA]]
 // CHECK-NEXT: checked_cast_br [[VAL]] : $A to $B, [[IS_B:bb.*]], [[NOT_B:bb[0-9]+]]
 //
@@ -120,14 +125,14 @@ func foo(_ y : A?) {
 //
 //   Switch out on the value in [[OB2]].
 // CHECK:    [[SWITCH_OB2]]([[VAL:%[0-9]+]] : @owned $Optional<B>):
-// CHECK:    [[T0:%.*]] = select_enum [[VAL]]
-// CHECK:    cond_br [[T0]], [[HAVE_B:bb[0-9]+]], [[FINISH_NIL_4:bb[0-9]+]]
+// CHECK-NEXT: [[VAL_COPY:%.*]] = copy_value [[VAL]]
+// CHECK-NEXT: switch_enum [[VAL_COPY]] : ${{.*}}, case #Optional.some!enumelt.1: [[HAVE_B:bb[0-9]+]], case #Optional.none!enumelt: [[FINISH_NIL_4:bb[0-9]+]]
 //
 // CHECK:    [[FINISH_NIL_4]]:
 // CHECK:      end_borrow [[BORROWED_ARG]] from [[ARG]]
 // CHECK:      br [[FINISH_NIL_0]]
 //
-// CHECK:    [[HAVE_B]]:
+// CHECK:    [[HAVE_B]](
 // CHECK:      [[UNWRAPPED_VAL:%.*]] = unchecked_enum_data [[VAL]]
 // CHECK:      [[REWRAPPED_VAL:%.*]] = enum $Optional<B>, #Optional.some!enumelt.1, [[UNWRAPPED_VAL]]
 // CHECK:      end_borrow [[BORROWED_ARG]] from [[ARG]]
@@ -171,7 +176,8 @@ func bar(_ y : A????) {
 // CHECK-NEXT:    [[PB:%.*]] = project_box [[X]]
 // CHECK-NEXT:    [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]]
 // CHECK-NEXT:    [[ARG_COPY:%.*]] = copy_value [[BORROWED_ARG]]
-// CHECK:         [[T1:%.*]] = select_enum [[ARG_COPY]]
+// CHECK-NEXT:    [[ARG_COPY_COPY:%.*]] = copy_value [[ARG_COPY]]
+// CHECK:         switch_enum [[ARG_COPY_COPY]]
 // CHECK:       bb1:
 // CHECK:         [[VAL:%.*]] = unchecked_enum_data [[ARG_COPY]]
 // CHECK-NEXT:    [[X_VALUE:%.*]] = init_enum_data_addr [[PB]] : $*Optional<B>, #Optional.some

test/SILGen/optional.swift

@@ -9,17 +9,18 @@ func testCall(_ f: (() -> ())?) {
 // CHECK:    bb0([[T0:%.*]] : @owned $Optional<@callee_guaranteed () -> ()>):
 // CHECK:      [[BORROWED_T0:%.*]] = begin_borrow [[T0]]
 // CHECK:      [[T0_COPY:%.*]] = copy_value [[BORROWED_T0]]
-// CHECK:      [[T1:%.*]] = select_enum [[T0_COPY]]
-// CHECK-NEXT: cond_br [[T1]], [[SOME:bb[0-9]+]], [[NONE:bb[0-9]+]]
-
+// CHECK:      [[T0_COPY_COPY:%.*]] = copy_value [[T0_COPY]]
+// CHECK-NEXT: switch_enum [[T0_COPY_COPY]] : $Optional<@callee_guaranteed () -> ()>, case #Optional.some!enumelt.1: [[SOME:bb[0-9]+]], case #Optional.none!enumelt: [[NONE:bb[0-9]+]]
+//
 // CHECK: [[NONE]]:
 // CHECK:   end_borrow [[BORROWED_T0]] from [[T0]]
 // CHECK:   br [[NOTHING_BLOCK_EXIT:bb[0-9]+]]
 
 //   If it does, project and load the value out of the implicitly unwrapped
 //   optional...
 
-// CHECK: [[SOME]]:
+// CHECK: [[SOME]]([[SOME_ARG:%.*]] :
+// CHECK-NEXT: destroy_value [[SOME_ARG]]
 // CHECK-NEXT: [[FN0:%.*]] = unchecked_enum_data [[T0_COPY]] : $Optional<@callee_guaranteed () -> ()>, #Optional.some!enumelt.1
 //   .... then call it
 // CHECK-NEXT: [[B:%.*]] = begin_borrow [[FN0]]
@@ -51,10 +52,13 @@ func testAddrOnlyCallResult<T>(_ f: (() -> T)?) {
 // CHECK-NEXT: [[TEMP:%.*]] = init_enum_data_addr [[PBX]]
 // CHECK-NEXT: [[READ:%.*]] = begin_access [read] [unknown] [[PBF]]
 //   Check whether 'f' holds a value.
-// CHECK:      [[T1:%.*]] = select_enum_addr [[READ]]
-// CHECK-NEXT: cond_br [[T1]], bb2, bb1
+// CHECK-NEXT: [[TEMP2:%.*]] = alloc_stack $Optional<@callee_guaranteed () -> @out T>
+// CHECK-NEXT: copy_addr [[READ]] to [initialization] [[TEMP2]]
+// CHECK-NEXT: [[TEMP2_LOADED:%.*]] = load [take] [[TEMP2]]
+// CHECK-NEXT: switch_enum [[TEMP2_LOADED]] : $Optional<@callee_guaranteed () -> @out T>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb1
 //   If so, pull out the value...
-// CHECK:    bb2:
+// CHECK:    bb2([[SOME_ARG:%.*]] :
+// CHECK-NEXT: destroy_value [[SOME_ARG]]
 // CHECK-NEXT: [[T1:%.*]] = unchecked_take_enum_data_addr [[READ]]
 // CHECK-NEXT: [[T0:%.*]] = load [copy] [[T1]]
 // CHECK-NEXT: end_access [[READ]]
@@ -64,6 +68,7 @@ func testAddrOnlyCallResult<T>(_ f: (() -> T)?) {
 //   ...and coerce to T?
 // CHECK: inject_enum_addr [[PBX]] {{.*}}some
 // CHECK:     destroy_value [[T0]]
+// CHECK-NEXT: dealloc_stack
 // CHECK-NEXT: br bb3
 //   Continuation block.
 // CHECK:    bb3
@@ -96,8 +101,8 @@ func wrap_then_unwrap<T>(_ x: T) -> T {
 // CHECK-LABEL: sil hidden @$S8optional10tuple_bind{{[_0-9a-zA-Z]*}}F
 func tuple_bind(_ x: (Int, String)?) -> String? {
   return x?.1
-  // CHECK:   cond_br {{%.*}}, [[NONNULL:bb[0-9]+]], [[NULL:bb[0-9]+]]
-  // CHECK: [[NONNULL]]:
+  // CHECK:   switch_enum {{%.*}}, case #Optional.some!enumelt.1: [[NONNULL:bb[0-9]+]], case #Optional.none!enumelt: [[NULL:bb[0-9]+]]
+  // CHECK: [[NONNULL]](
   // CHECK:   [[STRING:%.*]] = tuple_extract {{%.*}} : $(Int, String), 1
   // CHECK-NOT: destroy_value [[STRING]]
 }

test/SILGen/optional_lvalue.swift

@@ -63,9 +63,9 @@ func assign_optional_lvalue_computed(_ x: inout S?, _ y: Int) -> Int {
 func generate_int() -> Int { return 0 }
 
 // CHECK-LABEL: sil hidden @$S15optional_lvalue013assign_bound_a1_B0yySiSgzF
-// CHECK:         select_enum_addr
-// CHECK:         cond_br {{%.*}}, [[SOME:bb[0-9]+]], [[NONE:bb[0-9]+]]
-// CHECK:       [[SOME]]:
+// CHECK:         switch_enum {{%.*}} : $Optional<Int>, case #Optional.some!enumelt.1: [[SOME:bb[0-9]+]], case #Optional.none!enumelt: [[NONE:bb[0-9]+]]
+//
+// CHECK:       [[SOME]](
 // CHECK:         [[PAYLOAD:%.*]] = unchecked_take_enum_data_addr
 // CHECK:         [[FN:%.*]] = function_ref
 // CHECK:         [[T0:%.*]] = apply [[FN]]()