Merge pull request #40254 from atrick/fix-dead-stdlib-assert

Add isReadOnlyConstantEvaluableCall to handle stdlib asserts

Author: atrick

include/swift/SILOptimizer/Utils/ConstExpr.h

@@ -26,6 +26,7 @@
 
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/SourceLoc.h"
+#include "swift/SIL/ApplySite.h"
 #include "swift/SIL/SILBasicBlock.h"
 #include "llvm/ADT/SmallPtrSet.h"
 
@@ -211,6 +212,9 @@ bool hasConstantEvaluableAnnotation(SILFunction *fun);
 
 bool isConstantEvaluable(SILFunction *fun);
 
+/// Return true iff the \p applySite is constant-evaluable and read-only.
+bool isReadOnlyConstantEvaluableCall(FullApplySite applySite);
+
 /// Return true if and only if the given function \p fun is specially modeled
 /// by the constant evaluator. These are typically functions in the standard
 /// library, such as String.+=, Array.append, whose semantics is built into the

lib/SILOptimizer/Utils/ConstExpr.cpp

@@ -111,6 +111,27 @@ static llvm::Optional<WellKnownFunction> classifyFunction(SILFunction *fn) {
   return None;
 }
 
+static bool isReadOnlyFunction(WellKnownFunction function) {
+  switch (function) {
+  case WellKnownFunction::ArrayInitEmpty:
+  case WellKnownFunction::AllocateUninitializedArray:
+  case WellKnownFunction::StringInitEmpty:
+  case WellKnownFunction::StringMakeUTF8:
+  case WellKnownFunction::StringEquals:
+  case WellKnownFunction::StringEscapePercent:
+  case WellKnownFunction::BinaryIntegerDescription:
+    return true;
+
+  case WellKnownFunction::EndArrayMutation:
+  case WellKnownFunction::FinalizeUninitializedArray:
+  case WellKnownFunction::ArrayAppendElement:
+  case WellKnownFunction::StringAppend:
+  case WellKnownFunction::AssertionFailure:
+  case WellKnownFunction::DebugPrint:
+    return false;
+  }
+}
+
 /// Helper function for creating UnknownReason without a payload.
 static SymbolicValue getUnknown(ConstExprEvaluator &evaluator, SILNode *node,
                                 UnknownReason::UnknownKind kind) {
@@ -2291,3 +2312,39 @@ bool swift::isConstantEvaluable(SILFunction *fun) {
   return hasConstantEvaluableAnnotation(fun) ||
          isKnownConstantEvaluableFunction(fun);
 }
+
+/// Return true iff the \p applySite is constant-evaluable and read-only.
+///
+/// Functions annotated as "constant_evaluable" are assumed to be "side-effect
+/// free", unless their signature and substitution map indicates otherwise. A
+/// constant_evaluable function call is read only unless it:
+///   (1) has generic parameters
+///   (2) has inout parameters
+///   (3) has indirect results
+///
+/// Read-only constant evaluable functions can do only the following and
+/// nothing else:
+///   (1) The call may read any memory location.
+///   (2) The call may destroy owned parameters i.e., consume them.
+///   (3) The call may write into memory locations newly created by the call.
+///   (4) The call may use assertions, which traps at runtime on failure.
+///   (5) The call may return a non-generic value.
+///
+/// Essentially, these are calls whose "effect" is visible only in their return
+/// value or through the parameters that are destroyed. The return value
+/// is also guaranteed to have value semantics as it is non-generic and
+/// reference semantics is not constant evaluable.
+bool swift::isReadOnlyConstantEvaluableCall(FullApplySite applySite) {
+  SILFunction *callee = applySite.getCalleeFunction();
+  if (!callee)
+    return false;
+
+  if (auto knownFunction = classifyFunction(callee)) {
+    return isReadOnlyFunction(knownFunction.getValue());
+  }
+  if (!hasConstantEvaluableAnnotation(callee))
+    return false;
+
+  return !applySite.hasSubstitutions() && !getNumInOutArguments(applySite)
+         && !applySite.getNumIndirectSILResults();
+}

lib/SILOptimizer/Utils/InstructionDeleter.cpp

@@ -18,28 +18,6 @@
 
 using namespace swift;
 
-/// Return true iff the \p applySite calls a constant-evaluable function and
-/// it is non-generic and read/destroy only, which means that the call can do
-/// only the following and nothing else:
-///   (1) The call may read any memory location.
-///   (2) The call may destroy owned parameters i.e., consume them.
-///   (3) The call may write into memory locations newly created by the call.
-///   (4) The call may use assertions, which traps at runtime on failure.
-///   (5) The call may return a non-generic value.
-/// Essentially, these are calls whose "effect" is visible only in their return
-/// value or through the parameters that are destroyed. The return value
-/// is also guaranteed to have value semantics as it is non-generic and
-/// reference semantics is not constant evaluable.
-static bool isNonGenericReadOnlyConstantEvaluableCall(FullApplySite applySite) {
-  assert(applySite);
-  SILFunction *callee = applySite.getCalleeFunction();
-  if (!callee || !isConstantEvaluable(callee)) {
-    return false;
-  }
-  return !applySite.hasSubstitutions() && !getNumInOutArguments(applySite) &&
-         !applySite.getNumIndirectSILResults();
-}
-
 static bool hasOnlyIncidentalUses(SILInstruction *inst,
                                   bool disallowDebugUses = false) {
   for (SILValue result : inst->getResults()) {
@@ -160,7 +138,7 @@ static bool isScopeAffectingInstructionDead(SILInstruction *inst,
     // provided the parameter lifetimes are handled correctly, which is taken
     // care of by the function: \c deleteInstruction.
     FullApplySite applySite(cast<ApplyInst>(inst));
-    return isNonGenericReadOnlyConstantEvaluableCall(applySite);
+    return isReadOnlyConstantEvaluableCall(applySite);
   }
   default: {
     return false;

test/SILOptimizer/sil_combine_ossa.sil

@@ -5219,3 +5219,22 @@ bb0(%0 : @owned $Klass, %1 : $Builtin.Word):
   destroy_value %0 : $Klass
   return %11 : $AnyObject
 }
+
+// Test that DCE during SILCombine does not remove traps.
+// Tests isReadOnlyConstantEvaluable().
+sil hidden [noinline] [_semantics "programtermination_point"] @trapWrapper : $@convention(thin) () -> () {
+bb0:
+  %0 = builtin "int_trap"() : $Never
+  unreachable
+}
+
+// CHECK-LABEL: sil [ossa] @testTrap : $@convention(thin) () -> () {
+// CHECK: apply
+// CHECK-LABEL: } // end sil function 'testTrap'
+sil [ossa] @testTrap : $@convention(thin) () -> () {
+bb0:
+  %0 = function_ref @trapWrapper : $@convention(thin) () -> ()
+  %1 = apply %0() : $@convention(thin) () -> ()
+  %2 = tuple ()
+  return %2 : $()
+}