Merge pull request #85244 from aidan-hall/fixing-debug-info-rebase

Retain more debug info in optimized builds

Author: aidan-hall

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/TempLValueElimination.swift

@@ -180,6 +180,12 @@ private func tryEliminate(copy: CopyLikeInstruction, _ context: FunctionPassCont
       use.set(to: copy.destinationAddress, context)
     }
   }
+
+  // Salvage the debug variable attribute, if present.
+  if let debugVariable = allocStack.debugVariable {
+    let builder = Builder(before: firstUseOfAllocStack, location: allocStack.location, context)
+    builder.createDebugValue(value: copy.destinationAddress, debugVariable: debugVariable)
+  }
   context.erase(instruction: allocStack)
   context.erase(instructionIncludingAllUsers: copy.loadingInstruction)
 }

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -883,6 +883,11 @@ extension SimplifyContext {
     second.replace(with: replacement, self)
 
     if canEraseFirst {
+      // We only need to salvage first's debug info when !preserveDebugInfo and
+      // it has no non-debug uses.
+      if !preserveDebugInfo {
+        first.salvageDebugInfo(self)
+      }
       erase(instructionIncludingDebugUses: first)
     }
   }

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -102,6 +102,13 @@ public class Instruction : CustomStringConvertible, Hashable {
     context.notifyInstructionsChanged()
   }
 
+  /// Transfer debug info associated with (the result of) this instruction to a
+  /// new `debug_value` instruction before this instruction is deleted.
+  public final func salvageDebugInfo(_ context: some MutatingContext) {
+    BridgedContext.salvageDebugInfo(self.bridged)
+    context.notifyInstructionsChanged()
+  }
+
   public var mayTrap: Bool { false }
 
   final public var mayHaveSideEffects: Bool {

include/swift/SIL/SILBridging.h

@@ -1554,6 +1554,7 @@ struct BridgedContext {
   BRIDGED_INLINE void eraseBlock(BridgedBasicBlock block) const;
   static BRIDGED_INLINE void moveInstructionBefore(BridgedInstruction inst, BridgedInstruction beforeInst);
   static BRIDGED_INLINE void copyInstructionBefore(BridgedInstruction inst, BridgedInstruction beforeInst);
+  static BRIDGED_INLINE void salvageDebugInfo(BridgedInstruction inst);
 
     // SSAUpdater
 

include/swift/SIL/SILBridgingImpl.h

@@ -41,6 +41,7 @@
 #include "swift/SIL/SILVTable.h"
 #include "swift/SIL/SILWitnessTable.h"
 #include "swift/SILOptimizer/Utils/ConstExpr.h"
+#include "swift/SILOptimizer/Utils/DebugOptUtils.h"
 #include "swift/SIL/SILConstants.h"
 #include <stdbool.h>
 #include <stddef.h>
@@ -3212,6 +3213,10 @@ void BridgedContext::copyInstructionBefore(BridgedInstruction inst, BridgedInstr
   inst.unbridged()->clone(beforeInst.unbridged());
 }
 
+void BridgedContext::salvageDebugInfo(BridgedInstruction inst) {
+  swift::salvageDebugInfo(inst.unbridged());
+}
+
 OptionalBridgedFunction BridgedContext::lookupStdlibFunction(BridgedStringRef name) const {
   return {context->lookupStdlibFunction(name.unbridged())};
 }

lib/SILOptimizer/Transforms/SILMem2Reg.cpp

@@ -1968,11 +1968,16 @@ void MemoryToRegisters::removeSingleBlockAllocation(AllocStackInst *asi) {
       if (!runningVals) {
         // Loading from uninitialized memory is only acceptable if the type is
         // empty--an aggregate of types without storage.
+        const auto initialValue =
+            createEmptyAndUndefValue(asi->getElementType(), inst, ctx);
         runningVals = {
             LiveValues::toReplace(asi,
-                                  /*replacement=*/createEmptyAndUndefValue(
-                                      asi->getElementType(), inst, ctx)),
+                                  /*replacement=*/initialValue),
             /*isStorageValid=*/!doesLoadInvalidateStorage(inst)};
+        if (auto varInfo = asi->getVarInfo()) {
+          SILBuilderWithScope(inst, ctx).createDebugValue(
+              inst->getLoc(), initialValue, *varInfo);
+        }
       }
       auto *loadInst = dyn_cast<LoadInst>(inst);
       if (loadInst &&

lib/SILOptimizer/Utils/CanonicalizeInstruction.cpp

@@ -321,9 +321,8 @@ splitAggregateLoad(LoadOperation loadInst, CanonicalizeInstruction &pass) {
   }
 
   // Preserve the original load's debug information.
-  if (pass.preserveDebugInfo) {
-    swift::salvageLoadDebugInfo(loadInst);
-  }
+  swift::salvageLoadDebugInfo(loadInst);
+
   // Remove the now unused borrows.
   for (auto *borrow : borrows)
     nextII = killInstAndIncidentalUses(borrow, nextII, pass);

lib/SILOptimizer/Utils/ConstantFolding.cpp

@@ -20,6 +20,7 @@
 #include "swift/SIL/PatternMatch.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SILOptimizer/Utils/CastOptimizer.h"
+#include "swift/SILOptimizer/Utils/DebugOptUtils.h"
 #include "swift/SILOptimizer/Utils/InstOptUtils.h"
 #include "swift/SILOptimizer/Utils/InstructionDeleter.h"
 #include "llvm/ADT/APFloat.h"
@@ -1232,8 +1233,8 @@ static SILValue constantFoldIsConcrete(BuiltinInst *BI) {
   return inst;
 }
 
-SILValue swift::constantFoldBuiltin(BuiltinInst *BI,
-                                    std::optional<bool> &ResultsInError) {
+static SILValue constantFoldBuiltinWithoutSalvagingDebugInfo(BuiltinInst *BI,
+                                                             std::optional<bool> &ResultsInError) {
   const IntrinsicInfo &Intrinsic = BI->getIntrinsicInfo();
   SILModule &M = BI->getModule();
 
@@ -1444,6 +1445,20 @@ case BuiltinValueKind::id:
   return nullptr;
 }
 
+SILValue swift::constantFoldBuiltin(BuiltinInst *BI,
+                                    std::optional<bool> &ResultsInError) {
+  const auto value =
+      constantFoldBuiltinWithoutSalvagingDebugInfo(BI, ResultsInError);
+  // Salvage debug info of BI arguments if it was successfully folded.
+  if (value) {
+    for (auto arg : BI->getArguments()) {
+      if (auto *argInst = arg.getDefiningInstruction())
+        swift::salvageDebugInfo(argInst);
+    }
+  }
+  return value;
+}
+
 /// On success this places a new value for each result of Op->getUser() into
 /// Results. Results is guaranteed on success to have the same number of entries
 /// as results of User. If we could only simplify /some/ of an instruction's

test/DebugInfo/self-nostorage.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -primary-file %s -emit-ir -g -o - | %FileCheck %s
+// RUN: %target-swift-frontend -primary-file %s -emit-ir -g -O -o - | %FileCheck %s
 
 public struct S {
   func f() {

test/DebugInfo/sil_combine.sil

@@ -71,3 +71,26 @@ bb3:
 
 
 // CHECK-IR: ![[DBG_VAR]] = !DILocalVariable(name: "hello"
+
+struct T {
+  @_hasStorage let x: Builtin.Int32 { get }
+  init(x: Builtin.Int32)
+}
+
+// This test verifies that splitAggregateLoad in CanonicalizeInstruction.cpp
+// salvages debug info attached to the loaded aggregate in optimized builds.
+//
+// CHECK-LABEL: sil @split_aggregate_load : $@convention(thin) (@in T) -> Builtin.Int32 {
+// CHECK:       bb0([[ARG:%[0-9]+]] : $*T):
+// CHECK-NEXT:    [[ELEM_ADDR:%[0-9]+]] = struct_element_addr [[ARG]] : $*T, #T.x
+// CHECK-NEXT:    [[ELEM:%[0-9]+]] = load [[ELEM_ADDR]]
+// CHECK-NEXT:    debug_value [[ARG]] : $*T, let, name "var", expr op_deref
+// CHECK-NEXT:    return [[ELEM]] : $Builtin.Int32
+// CHECK-LABEL: } // end sil function 'split_aggregate_load'
+sil @split_aggregate_load : $@convention(thin) (@in T) -> Builtin.Int32 {
+bb0(%0 : $*T):
+  %1 = load %0
+  debug_value %1, let, name "var"
+  %2 = struct_extract %1, #T.x
+  return %2
+}