Add CanonicalizeInstruction preserveDebugInfo, fix Onone debug info

Minor debug info fixes to avoid dropping debug info at -Onon.

Author: atrick

include/swift/SILOptimizer/Utils/CanonicalizeInstruction.h

@@ -42,11 +42,16 @@ struct CanonicalizeInstruction {
   const char *debugType = defaultDebugType;
   DeadEndBlocks &deadEndBlocks;
   InstModCallbacks callbacks;
+  bool preserveDebugInfo;
 
   CanonicalizeInstruction(const char *passDebugType,
                           DeadEndBlocks &deadEndBlocks)
       : deadEndBlocks(deadEndBlocks),
         callbacks() {
+
+    preserveDebugInfo = getFunction()->getEffectiveOptimizationMode()
+      <= OptimizationMode::NoOptimization;
+
 #ifndef NDEBUG
     if (llvm::DebugFlag && !llvm::isCurrentDebugType(debugType))
       debugType = passDebugType;
@@ -68,6 +73,9 @@ struct CanonicalizeInstruction {
 
   const SILFunction *getFunction() const { return deadEndBlocks.getFunction(); }
 
+  // TODO: callbacks should come from the current InstructionDeleter.
+  InstModCallbacks &getCallbacks() { return callbacks; }
+
   /// Rewrite this instruction, based on its operands and uses, into a more
   /// canonical representation.
   ///

lib/SILOptimizer/Utils/CanonicalizeInstruction.cpp

@@ -414,6 +414,14 @@ broadenSingleElementStores(StoreInst *storeInst,
 /// copy. The only way to guarantee the lifetime of a variable is to use a
 /// borrow scope--copy/destroy is insufficient by itself.
 ///
+/// FIXME: This removes debug_value instructions aggressively as part of
+/// SILGenCleanup. Instead, debug_values should be canonicalized before copy
+/// elimination so that we never see the pattern:
+///   %b = begin_borrow
+///   %c = copy %b
+///   end_borrow %b
+///   debug_value %c
+///
 /// FIXME: Technically this should be guarded by a compiler flag like
 /// -enable-copy-propagation until SILGen protects scoped variables by
 /// borrow scopes.
@@ -423,20 +431,21 @@ eliminateSimpleCopies(CopyValueInst *cvi, CanonicalizeInstruction &pass) {
 
   // Eliminate copies that only have destroy_value uses.
   SmallVector<DestroyValueInst *, 8> destroys;
-  for (auto *use : getNonDebugUses(cvi)) {
+  for (Operand *use : cvi->getUses()) {
     if (auto *dvi = dyn_cast<DestroyValueInst>(use->getUser())) {
       destroys.push_back(dvi);
       continue;
     }
+    if (!pass.preserveDebugInfo && isa<DebugValueInst>(use->getUser())) {
+      continue;
+    }
     return next;
   }
 
   while (!destroys.empty()) {
     next = killInstruction(destroys.pop_back_val(), next, pass);
   }
-
-  next = killInstAndIncidentalUses(cvi, next, pass);
-  return next;
+  return killInstAndIncidentalUses(cvi, next, pass);
 }
 
 /// Unlike dead copy elimination, dead borrows can be safely removed because the
@@ -538,8 +547,11 @@ CanonicalizeInstruction::canonicalize(SILInstruction *inst) {
   // If we have ownership and are not in raw SIL, eliminate unneeded forwarding
   // insts. We don't do this in raw SIL as not to disturb the codegen read by
   // diagnostics.
+  //
+  // TODO: fix tryEliminateUnneededForwardingInst to handle debug uses.
   auto *fn = inst->getFunction();
-  if (fn->hasOwnership() && fn->getModule().getStage() != SILStage::Raw) {
+  if (!preserveDebugInfo && fn->hasOwnership()
+      && fn->getModule().getStage() != SILStage::Raw) {
     if (OwnershipForwardingMixin::isa(inst))
       if (auto newNext = tryEliminateUnneededForwardingInst(inst, *this))
         return *newNext;