Merge pull request swiftlang#36632 from gottesmm/opt_remark_runtime_cast_remark

[opt-remark] Add support for emitting remarks about runtime casts.

Author: gottesmm

include/swift/SIL/Consumption.h

@@ -18,6 +18,9 @@
 #ifndef SWIFT_SIL_CONSUMPTION_H
 #define SWIFT_SIL_CONSUMPTION_H
 
+#include "llvm/Support/ErrorHandling.h"
+#include <cstdint>
+
 namespace swift {
 
 /// Is an operation a "take"?  A take consumes the original value,

include/swift/SIL/DebugUtils.h

@@ -218,6 +218,96 @@ inline SILBasicBlock::iterator eraseFromParentWithDebugInsts(
 bool hasNonTrivialNonDebugTransitiveUsers(
     PointerUnion<SILInstruction *, SILArgument *> V);
 
+/// A light weight abstraction on top of an instruction that carries within it
+/// information about a debug variable. This allows one to write high level code
+/// over the set of such instructions with greater correctness by using
+/// exhaustive switches, methods, and keeping it light weight by using *, ->
+/// operators to access functionality from the underlying instruction when
+/// needed.
+struct DebugVarCarryingInst {
+  enum class Kind {
+    Invalid = 0,
+    DebugValue,
+    DebugValueAddr,
+    AllocStack,
+    AllocBox,
+  };
+
+  Kind kind;
+  SILInstruction *inst;
+
+  DebugVarCarryingInst() : kind(Kind::Invalid), inst(nullptr) {}
+  DebugVarCarryingInst(DebugValueInst *dvi)
+      : kind(Kind::DebugValue), inst(dvi) {}
+  DebugVarCarryingInst(DebugValueAddrInst *dvai)
+      : kind(Kind::DebugValueAddr), inst(dvai) {}
+  DebugVarCarryingInst(AllocStackInst *asi)
+      : kind(Kind::AllocStack), inst(asi) {}
+  DebugVarCarryingInst(AllocBoxInst *abi) : kind(Kind::AllocBox), inst(abi) {}
+  DebugVarCarryingInst(SILInstruction *newInst)
+      : kind(Kind::Invalid), inst(nullptr) {
+    switch (newInst->getKind()) {
+    default:
+      return;
+    case SILInstructionKind::DebugValueInst:
+      kind = Kind::DebugValue;
+      break;
+    case SILInstructionKind::DebugValueAddrInst:
+      kind = Kind::DebugValueAddr;
+      break;
+    case SILInstructionKind::AllocStackInst:
+      kind = Kind::AllocStack;
+      break;
+    case SILInstructionKind::AllocBoxInst:
+      kind = Kind::AllocBox;
+      break;
+    }
+    inst = newInst;
+  }
+
+  /// Enable the composition struct to be used as an instruction easily. We use
+  /// a '*' so that in the source it is easily visible to the eye that something
+  /// is happening here.
+  SILInstruction *operator*() const { return inst; }
+
+  /// Enable one to access the methods of the wrapped instruction using
+  /// '->'. This keeps the wrapper light weight.
+  SILInstruction *operator->() const { return inst; }
+
+  /// Add support for this struct in `if` statement.
+  explicit operator bool() const { return bool(kind); }
+
+  VarDecl *getDecl() const {
+    switch (kind) {
+    case Kind::Invalid:
+      llvm_unreachable("Invalid?!");
+    case Kind::DebugValue:
+      return cast<DebugValueInst>(inst)->getDecl();
+    case Kind::DebugValueAddr:
+      return cast<DebugValueAddrInst>(inst)->getDecl();
+    case Kind::AllocStack:
+      return cast<AllocStackInst>(inst)->getDecl();
+    case Kind::AllocBox:
+      return cast<AllocBoxInst>(inst)->getDecl();
+    }
+  }
+
+  Optional<SILDebugVariable> getVarInfo() const {
+    switch (kind) {
+    case Kind::Invalid:
+      llvm_unreachable("Invalid?!");
+    case Kind::DebugValue:
+      return cast<DebugValueInst>(inst)->getVarInfo();
+    case Kind::DebugValueAddr:
+      return cast<DebugValueAddrInst>(inst)->getVarInfo();
+    case Kind::AllocStack:
+      return cast<AllocStackInst>(inst)->getVarInfo();
+    case Kind::AllocBox:
+      return cast<AllocBoxInst>(inst)->getVarInfo();
+    }
+  }
+};
+
 } // end namespace swift
 
 #endif // SWIFT_SIL_DEBUGUTILS_H

include/swift/SIL/DynamicCasts.h

@@ -32,7 +32,7 @@ class SILBuilder;
 class SILLocation;
 class SILModule;
 class SILType;
-enum class CastConsumptionKind : unsigned char;
+enum class CastConsumptionKind : uint8_t;
 struct SILDynamicCastInst;
 
 enum class DynamicCastFeasibility {

include/swift/SIL/MemAccessUtils.h

@@ -1164,16 +1164,25 @@ namespace swift {
 /// uninitialized.
 bool memInstMustInitialize(Operand *memOper);
 
-/// Is this an alloc_stack instruction that is:
+/// Is this an alloc_stack instruction that we can prove is:
 ///
 /// 1. Only initialized once in its own def block.
 /// 2. Never written to again except by destroy_addr.
 ///
-/// On return, destroyingUsers contains the list of users that destroy the
-/// alloc_stack. If the alloc_stack is destroyed in pieces, we do not guarantee
-/// that the list of destroying users is a minimal jointly post-dominating set.
-bool isSingleInitAllocStack(AllocStackInst *asi,
-                            SmallVectorImpl<Operand *> &destroyingUses);
+/// Then we return the single initializing use and if \p destroyingUsers was
+/// non-null, On return, if non-null, \p destroyingUsers contains the list of
+/// users that destroy the alloc_stack. If the alloc_stack is destroyed in
+/// pieces, we do not guarantee that the list of destroying users is a minimal
+/// jointly post-dominating set.
+Operand *getSingleInitAllocStackUse(
+    AllocStackInst *asi, SmallVectorImpl<Operand *> *destroyingUses = nullptr);
+
+/// Same as getSingleInitAllocStack except we throw away the single use and just
+/// provide a bool.
+inline bool isSingleInitAllocStack(AllocStackInst *asi,
+                                   SmallVectorImpl<Operand *> &destroyingUses) {
+  return getSingleInitAllocStackUse(asi, &destroyingUses);
+}
 
 /// Return true if the given address value is produced by a special address
 /// producer that is only used for local initialization, not formal access.

lib/SIL/Utils/MemAccessUtils.cpp

@@ -16,6 +16,8 @@
 #include "swift/SIL/SILModule.h"
 #include "swift/SIL/SILUndef.h"
 #include "swift/SIL/DynamicCasts.h"
+#include "swift/SIL/Consumption.h"
+#include "swift/SIL/SILInstruction.h"
 #include "llvm/Support/Debug.h"
 
 using namespace swift;
@@ -1545,12 +1547,13 @@ bool swift::memInstMustInitialize(Operand *memOper) {
   }
 }
 
-bool swift::isSingleInitAllocStack(AllocStackInst *asi,
-                                   SmallVectorImpl<Operand *> &destroyingUses) {
+Operand *
+swift::getSingleInitAllocStackUse(AllocStackInst *asi,
+                                  SmallVectorImpl<Operand *> *destroyingUses) {
   // For now, we just look through projections and rely on memInstMustInitialize
   // to classify all other uses as init or not.
   SmallVector<Operand *, 32> worklist(asi->getUses());
-  bool foundInit = false;
+  Operand *singleInit = nullptr;
 
   while (!worklist.empty()) {
     auto *use = worklist.pop_back_val();
@@ -1571,14 +1574,42 @@ bool swift::isSingleInitAllocStack(AllocStackInst *asi,
         continue;
       }
       // Treat load [take] as a write.
-      return false;
+      return nullptr;
     }
 
     switch (user->getKind()) {
     default:
       break;
+    case SILInstructionKind::UnconditionalCheckedCastAddrInst: {
+      auto *uccai = cast<UnconditionalCheckedCastAddrInst>(user);
+      // Only handle the case where we are doing a take of our alloc_stack as a
+      // source value. If we are the dest, then something else is happening!
+      // Break!
+      if (use->get() == uccai->getDest())
+        break;
+      // Ok, we are the Src and are performing a take. Treat it as a destroy!
+      if (destroyingUses)
+        destroyingUses->push_back(use);
+      continue;
+    }
+    case SILInstructionKind::CheckedCastAddrBranchInst: {
+      auto *ccabi = cast<CheckedCastAddrBranchInst>(user);
+      // We only handle the case where we are doing a take of our alloc_stack as
+      // a source.
+      //
+      // TODO: Can we expand this?
+      if (use->get() == ccabi->getDest())
+        break;
+      if (ccabi->getConsumptionKind() != CastConsumptionKind::TakeAlways)
+        break;
+      // Ok, we are the Src and are performing a take. Treat it as a destroy!
+      if (destroyingUses)
+        destroyingUses->push_back(use);
+      continue;
+    }
     case SILInstructionKind::DestroyAddrInst:
-      destroyingUses.push_back(use);
+      if (destroyingUses)
+        destroyingUses->push_back(use);
       continue;
     case SILInstructionKind::DeallocStackInst:
     case SILInstructionKind::LoadBorrowInst:
@@ -1589,21 +1620,21 @@ bool swift::isSingleInitAllocStack(AllocStackInst *asi,
     // See if we have an initializer and that such initializer is in the same
     // block.
     if (memInstMustInitialize(use)) {
-      if (user->getParent() != asi->getParent() || foundInit) {
-        return false;
+      if (user->getParent() != asi->getParent() || singleInit) {
+        return nullptr;
       }
 
-      foundInit = true;
+      singleInit = use;
       continue;
     }
 
     // Otherwise, if we have found something not in our allowlist, return false.
-    return false;
+    return nullptr;
   }
 
   // We did not find any users that we did not understand. So we can
-  // conservatively return true here.
-  return true;
+  // conservatively return the single initializing write that we found.
+  return singleInit;
 }
 
 /// Return true if the given address value is produced by a special address

lib/SILOptimizer/SemanticARC/LoadCopyToLoadBorrowOpt.cpp

@@ -281,8 +281,10 @@ class StorageGuaranteesLoadVisitor
   /// See if we have an alloc_stack that is only written to once by an
   /// initializing instruction.
   void visitStackAccess(AllocStackInst *stack) {
-    SmallVector<Operand *, 8> destroyAddrOperands;
-    bool initialAnswer = isSingleInitAllocStack(stack, destroyAddrOperands);
+    // These will contain all of the address destroying operands that form the
+    // lifetime of the object. They may not be destroy_addr!
+    SmallVector<Operand *, 8> addrDestroyingOperands;
+    bool initialAnswer = isSingleInitAllocStack(stack, addrDestroyingOperands);
     if (!initialAnswer)
       return answer(true);
 
@@ -291,7 +293,7 @@ class StorageGuaranteesLoadVisitor
     LinearLifetimeChecker checker(ctx.getDeadEndBlocks());
     // Returns true on success. So we invert.
     bool foundError = !checker.validateLifetime(
-        stack, destroyAddrOperands /*consuming users*/,
+        stack, addrDestroyingOperands /*consuming users*/,
         liveRange.getAllConsumingUses() /*non consuming users*/);
     return answer(foundError);
   }