[Performance diagnostics] Enable checking of throw instructions

When performance diagnostics were introduced, typed throws didn't exist
so it was not generally possible to have throws anywhere without
triggering performance diagnostics. As a short term hack, we disabled
checking of `throw` instructions and the basic blocks that terminate
in a `throw`.

Now that typed throws is available and can be used to eliminate
allocations with error handling, remove all of the hacks. We'll now
diagnose attempts to throw or catch existential values (e.g., the `any
Error` used for untyped throws), but typed throws are fine.

Author: DougGregor

lib/SILOptimizer/Mandatory/PerformanceDiagnostics.cpp

@@ -290,21 +290,6 @@ bool PerformanceDiagnostics::visitFunction(SILFunction *function,
     if (isa<UnreachableInst>(block.getTerminator()))
       continue;
 
-    // TODO: it's not yet clear how to deal with error existentials.
-    // Ignore them for now. If we have typed throws we could ban error existentials
-    // because typed throws would provide and alternative.
-    if (isa<ThrowInst>(block.getTerminator()))
-      continue;
-
-    // If a function has multiple throws, all throw-path branch to the single throw-block.
-    if (SILBasicBlock *succ = block.getSingleSuccessorBlock()) {
-      if (isa<ThrowInst>(succ->getTerminator()))
-        continue;
-    }
-
-    if (!neBlocks.isNonErrorHandling(&block))
-      continue;
-
     for (SILInstruction &inst : block) {
       if (visitInst(&inst, perfConstr, parentLoc)) {
         if (inst.getLoc().getSourceLoc().isInvalid()) {

test/SILOptimizer/performance-annotations.swift

@@ -101,13 +101,22 @@ func errorExistential(_ b: Bool) throws -> Int {
   if b {
     return 28
   }
-  throw MyError()
+  throw MyError() // expected-error{{Using type 'MyError' can cause metadata allocation or locks}}
+}
+
+@_noLocks
+func concreteThrowsExistential(_ b: Bool) throws -> Int {
+  if b {
+    return 28
+  }
+
+  throw ErrorEnum.tryAgain // expected-error{{Using type 'any Error' can cause metadata allocation or locks}}
 }
 
 @_noLocks
 func multipleThrows(_ b1: Bool, _ b2: Bool) throws -> Int {
   if b1 {
-    throw MyError()
+    throw MyError() // expected-error{{Using type 'MyError' can cause metadata allocation or locks}}
   }
   if b2 {
     throw MyError2()
@@ -119,7 +128,7 @@ func multipleThrows(_ b1: Bool, _ b2: Bool) throws -> Int {
 func testCatch(_ b: Bool) throws -> Int? {
   do {
     return try errorExistential(true)
-  } catch let e as MyError {
+  } catch let e as MyError { // expected-error{{this code performs reference counting operations which can cause locking}}
     print(e)
     return nil
   }