Merge pull request #28719 from gottesmm/pr-39c568e8fa7a8e0f2ad1323b55401d557a150ad9

[diagnose-unreachable] Fix a small part of diagnose unreachable that did not handle ossa correctly.

Author: gottesmm

lib/SILOptimizer/Mandatory/DiagnoseUnreachable.cpp

@@ -208,9 +208,8 @@ static void propagateBasicBlockArgs(SILBasicBlock &BB) {
 static bool constantFoldEnumTerminator(SILBasicBlock &BB,
                                        UnreachableUserCodeReportingState *State,
                                        SwitchEnumInstBase *SUI,
-                                       const EnumElementDecl *TheEnumElem,
-                                       SILValue value = SILValue(),
-                                       SILValue defaultValue = SILValue()) {
+                                       EnumElementDecl *TheEnumElem,
+                                       EnumInst *EnumInst) {
   SILBasicBlock *TheSuccessorBlock = nullptr;
   int ReachableBlockIdx = -1;
   for (unsigned Idx = 0; Idx < SUI->getNumCases(); ++Idx) {
@@ -251,11 +250,9 @@ static bool constantFoldEnumTerminator(SILBasicBlock &BB,
     // value.
     SILValue branchOperand;
     if (TheSuccessorBlock != DB) {
-      assert(value);
-      branchOperand = value;
+      branchOperand = B.createUncheckedEnumData(Loc, EnumInst, TheEnumElem);
     } else {
-      assert(defaultValue);
-      branchOperand = defaultValue;
+      branchOperand = EnumInst;
     }
     B.createBranch(Loc, TheSuccessorBlock, branchOperand);
   } else
@@ -297,6 +294,81 @@ static bool constantFoldEnumTerminator(SILBasicBlock &BB,
   return true;
 }
 
+static bool constantFoldEnumAddrTerminator(
+    SILBasicBlock &BB, UnreachableUserCodeReportingState *State,
+    SwitchEnumInstBase *SUI, const EnumElementDecl *TheEnumElem) {
+  SILBasicBlock *TheSuccessorBlock = nullptr;
+  int ReachableBlockIdx = -1;
+  for (unsigned Idx = 0; Idx < SUI->getNumCases(); ++Idx) {
+    const EnumElementDecl *EI;
+    SILBasicBlock *BI;
+    std::tie(EI, BI) = SUI->getCase(Idx);
+    if (EI == TheEnumElem) {
+      TheSuccessorBlock = BI;
+      ReachableBlockIdx = Idx;
+      break;
+    }
+  }
+
+  SILBasicBlock *DB = nullptr;
+  if (!TheSuccessorBlock) {
+    if (SUI->hasDefault()) {
+      DB = SUI->getDefaultBB();
+      if (!isa<UnreachableInst>(DB->getTerminator())) {
+        TheSuccessorBlock = DB;
+        ReachableBlockIdx = SUI->getNumCases();
+      }
+    }
+  }
+
+  // Not fully covered switches will be diagnosed later. SILGen represents
+  // them with a Default basic block with an unreachable instruction.
+  // We are going to produce an error on all unreachable instructions not
+  // eliminated by DCE.
+  if (!TheSuccessorBlock)
+    return false;
+
+  // Replace the switch with a branch to the TheSuccessorBlock.
+  SILBuilderWithScope B(&BB, SUI);
+  SILLocation Loc = SUI->getLoc();
+  B.createBranch(Loc, TheSuccessorBlock);
+
+  // Produce diagnostic info if we are not within an inlined function or
+  // template instantiation.
+  // FIXME: Do not report if we are within a template instantiation.
+  assert(ReachableBlockIdx >= 0);
+  if (Loc.is<RegularLocation>() && State) {
+    // Find the first unreachable block in the switch so that we could use
+    // it for better diagnostics.
+    SILBasicBlock *UnreachableBlock = nullptr;
+    if (SUI->getNumCases() > 1) {
+      // More than one case.
+      UnreachableBlock = (ReachableBlockIdx == 0) ? SUI->getCase(1).second
+                                                  : SUI->getCase(0).second;
+    } else {
+      if (SUI->getNumCases() == 1 && SUI->hasDefault()) {
+        // One case and a default.
+        UnreachableBlock = (ReachableBlockIdx == 0) ? SUI->getDefaultBB()
+                                                    : SUI->getCase(0).second;
+      }
+    }
+
+    // Generate diagnostic info.
+    if (UnreachableBlock &&
+        !State->PossiblyUnreachableBlocks.count(UnreachableBlock)) {
+      State->PossiblyUnreachableBlocks.insert(UnreachableBlock);
+      State->MetaMap.insert(std::pair<const SILBasicBlock *, UnreachableInfo>(
+          UnreachableBlock,
+          UnreachableInfo{UnreachableKind::FoldedSwitchEnum, Loc, true}));
+    }
+  }
+
+  LLVM_DEBUG(llvm::dbgs() << "Folding terminator: " << *SUI);
+  recursivelyDeleteTriviallyDeadInstructions(SUI, true);
+  NumTerminatorsFolded++;
+  return true;
+}
+
 static InjectEnumAddrInst *
 getAllocStackSingleInitializingInjectEnumAddr(SwitchEnumAddrInst *SEAI) {
   auto *stackSlot = dyn_cast<AllocStackInst>(SEAI->getOperand());
@@ -506,10 +578,8 @@ static bool constantFoldTerminator(SILBasicBlock &BB,
   //   br bb2
   if (auto *SEI = dyn_cast<SwitchEnumInst>(TI)) {
     if (auto *TheEnum = dyn_cast<EnumInst>(SEI->getOperand())) {
-      SILValue operand =
-          TheEnum->hasOperand() ? TheEnum->getOperand() : SILValue();
       return constantFoldEnumTerminator(BB, State, SEI, TheEnum->getElement(),
-                                        operand /*case*/, TheEnum /*default*/);
+                                        TheEnum);
     }
   }
   if (auto *SEAI = dyn_cast<SwitchEnumAddrInst>(TI)) {
@@ -520,7 +590,8 @@ static bool constantFoldTerminator(SILBasicBlock &BB,
     //
     // TODO: This needs a better name.
     if (auto *IEAI = getAllocStackSingleInitializingInjectEnumAddr(SEAI)) {
-      return constantFoldEnumTerminator(BB, State, SEAI, IEAI->getElement());
+      return constantFoldEnumAddrTerminator(BB, State, SEAI,
+                                            IEAI->getElement());
     }
   }
 

test/SILOptimizer/diagnose_unreachable.sil

@@ -471,7 +471,9 @@ class Klass2 {}
 
 // CHECK-LABEL: sil [ossa] @constant_fold_diagnose_unreachable_succ_match : $@convention(thin) (@owned Klass1) -> () {
 // CHECK: bb0([[ARG:%.*]] :
-// CHECK:   destroy_value [[ARG]]
+// CHECK:   [[ENUM_VAL:%.*]] = enum $Either<Klass1, Klass2>, #Either.left!enumelt.1, [[ARG]]
+// CHECK:   [[RESULT:%.*]] = unchecked_enum_data [[ENUM_VAL]]
+// CHECK:   destroy_value [[RESULT]]
 // CHECK: } // end sil function 'constant_fold_diagnose_unreachable_succ_match'
 sil [ossa] @constant_fold_diagnose_unreachable_succ_match : $@convention(thin) (@owned Klass1) -> () {
 bb0(%0 : @owned $Klass1):
@@ -760,3 +762,23 @@ bb2:
   %9999 = tuple()
   return %9999 : $()
 }
+
+// Just make sure we apply the optimization and do not trigger the ownership verifier
+//
+// CHECK-LABEL: sil [ossa] @constant_fold_switch_enum_with_owned_payload :
+// CHECK: bb0(
+// CHECK:   br bb1
+// CHECK: bb1:
+// CHECK:   return
+// CHECK: } // end sil function 'constant_fold_switch_enum_with_owned_payload'
+sil [ossa] @constant_fold_switch_enum_with_owned_payload : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject {
+bb0(%0 : @owned $Builtin.NativeObject):
+  %1 = enum $FakeOptional<Builtin.NativeObject>, #FakeOptional.some!enumelt.1, %0 : $Builtin.NativeObject
+  switch_enum %1 : $FakeOptional<Builtin.NativeObject>, case #FakeOptional.some!enumelt.1: bb1, case #FakeOptional.none!enumelt: bb2
+
+bb1(%2 : @owned $Builtin.NativeObject):
+  return %2 : $Builtin.NativeObject
+
+bb2:
+  unreachable
+}