[6.1] SIL: builtin willThrow does not modify memory or release

This enables access enforcement analysis to classify a dynamic begin_access in
access patterns (such as the one below) involving a throwing function as not
having nested conflicts.

```
struct Stack {
  var items : [UInt8]

  mutating func pop() throws -> UInt8 {
    guard let item = items.popLast() else { throw SomeErr.err }
    return item
  }
  ...
}

class Container {
  private var ref : Stack

  @inline(never)
  internal func someMethod() throws {
     try ref.pop()
  }
  ...
}
```

Scope: Performance improvement
Risk: Medium, we are changing the side-effects of willThrow which should
not matter all that match. There is a second order effect: other wrongly
computed/assigned could now become visible.

Original PR: #78091
Reviewed by: Erik Eckstein

rdar://141182074

(cherry picked from commit fa01d8d)

Author: aschwaighofer

lib/SIL/IR/SILInstruction.cpp

@@ -997,6 +997,8 @@ MemoryBehavior SILInstruction::getMemoryBehavior() const {
       return BI->getArguments().size() > 0
         ? MemoryBehavior::MayWrite
         : MemoryBehavior::None;
+    } else if (BInfo.ID == BuiltinValueKind::WillThrow) {
+      return MemoryBehavior::MayRead;
     }
     if (BInfo.ID != BuiltinValueKind::None)
       return BInfo.isReadNone() ? MemoryBehavior::None
@@ -1188,6 +1190,7 @@ bool SILInstruction::mayRelease() const {
     if (auto Kind = BI->getBuiltinKind()) {
       switch (Kind.value()) {
         case BuiltinValueKind::CopyArray:
+        case BuiltinValueKind::WillThrow:
           return false;
         default:
           break;
@@ -1497,6 +1500,14 @@ bool SILInstruction::isTriviallyDuplicatable() const {
 }
 
 bool SILInstruction::mayTrap() const {
+  if (auto *BI = dyn_cast<BuiltinInst>(this)) {
+    if (auto Kind = BI->getBuiltinKind()) {
+      if (Kind.value() == BuiltinValueKind::WillThrow) {
+        // We don't want willThrow instructions to be removed.
+        return true;
+      }
+    }
+  }
   switch(getKind()) {
   case SILInstructionKind::CondFailInst:
   case SILInstructionKind::UnconditionalCheckedCastInst:

test/SILOptimizer/access_enforcement_opts.sil

@@ -1697,3 +1697,17 @@ bb0(%0 : ${ var Int64 }):
   end_access %access : $*Int64
   return %val : $Int64
 }
+
+// CHECK-LABEL: sil @willThrow : $@convention(thin) (RefElemNoConflictClass, @guaranteed any Error) -> () {
+// CHECK:  begin_access [modify] [dynamic] [no_nested_conflict]
+// CHECK-LABEL: } // end sil function 'willThrow'
+
+sil @willThrow : $@convention(thin) (RefElemNoConflictClass, @guaranteed any Error) -> () {
+bb0(%0 : $RefElemNoConflictClass, %1 : $any Error):
+  %x = ref_element_addr %0 : $RefElemNoConflictClass, #RefElemNoConflictClass.x
+  %b3 = begin_access [modify] [dynamic] %x : $*Int32
+  %w = builtin "willThrow"(%1 : $any Error) : $()
+  end_access %b3 : $*Int32
+  %10 = tuple ()
+  return %10 : $()
+}

test/SILOptimizer/side_effects.sil

@@ -57,6 +57,9 @@ struct Ptr {
   var p: Int32
 }
 
+enum SomeErr : Error {
+    case err
+}
 
 sil_global public @global_var : $Int32
 
@@ -1243,3 +1246,14 @@ sil @test_consuming_in_with_unreachable : $@convention(thin) (@in X) -> () {
 bb0(%0 : $*X):
   unreachable
 }
+
+// CHECK-LABEL: sil @test_willThrow_builtin
+// CHECK: [%0: read v**.c*.v**, copy v**.c*.v**]
+// CHECK: [global: read,copy,deinit_barrier]
+
+sil @test_willThrow_builtin : $@convention(thin) (@guaranteed any Error) -> () {
+bb0(%0: $any Error):
+  %1 = builtin "willThrow"(%0 : $any Error) : $()
+  %r = tuple ()
+  return %r : $()
+}