SIL: add a debug_step instruction

This instruction can be inserted by Onone optimizations as a replacement for deleted instructions to
ensure that it's possible to single step on its location.

Author: eeckstein

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -134,6 +134,11 @@ public struct Builder {
     return notifyNew(SILBuilder_createDestroyValue(bridged, operand.bridged).getAs(DestroyValueInst.self))
   }
 
+  @discardableResult
+  public func createDebugStep() -> DebugStepInst {
+    return notifyNew(SILBuilder_createDebugStep(bridged).getAs(DebugStepInst.self))
+  }
+
   @discardableResult
   public func createApply(
     function: Value,

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -291,6 +291,8 @@ final public class FixLifetimeInst : Instruction, UnaryInstruction {}
 
 final public class DebugValueInst : Instruction, UnaryInstruction {}
 
+final public class DebugStepInst : Instruction {}
+
 final public class UnconditionalCheckedCastAddrInst : Instruction {
   public override var mayTrap: Bool { true }
 }

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -50,6 +50,7 @@ public func registerSILClasses() {
   register(MarkUninitializedInst.self)
   register(FixLifetimeInst.self)
   register(DebugValueInst.self)
+  register(DebugStepInst.self)
   register(UnconditionalCheckedCastAddrInst.self)
   register(SetDeallocatingInst.self)
   register(EndApplyInst.self)

docs/SIL.rst

@@ -3952,6 +3952,20 @@ SIL DIExpression can have elements with various types, like AST nodes or strings
 
 The ``[trace]`` flag is available for compiler unit testing. It is not produced during normal compilation. It is used combination with internal logging and optimization controls to select specific values to trace or to transform. For example, liveness analysis combines all "traced" values into a single live range with multiple definitions. This exposes corner cases that cannot be represented by passing valid SIL through the pipeline.
 
+debug_step
+``````````
+
+::
+
+  sil-instruction ::= debug_step
+
+  debug_step
+
+This instruction is inserted by Onone optimizations as a replacement for deleted instructions to
+ensure that it's possible to set a breakpoint on its location.
+
+It is code-generated to a NOP instruction.
+
 Testing
 ~~~~~~~
 

include/swift/SIL/SILBridging.h

@@ -465,6 +465,7 @@ BridgedInstruction SILBuilder_createCopyAddr(BridgedBuilder builder,
           SwiftInt takeSource, SwiftInt initializeDest);
 BridgedInstruction SILBuilder_createDestroyValue(BridgedBuilder builder,
           BridgedValue op);
+BridgedInstruction SILBuilder_createDebugStep(BridgedBuilder builder);
 BridgedInstruction SILBuilder_createApply(BridgedBuilder builder,
           BridgedValue function, swift::SubstitutionMap subMap,
           BridgedValueArray arguments, bool isNonThrowing, bool isNonAsync,

include/swift/SIL/SILBuilder.h

@@ -985,6 +985,10 @@ class SILBuilder {
                                        bool wasMoved = false,
                                        bool trace = false);
 
+  DebugStepInst *createDebugStep(SILLocation Loc) {
+    return insert(new (getModule()) DebugStepInst(getSILDebugLocation(Loc)));
+  }
+
   /// Create a debug_value according to the type of \p src
   SILInstruction *emitDebugDescription(SILLocation Loc, SILValue src,
                                        SILDebugVariable Var) {

include/swift/SIL/SILCloner.h

@@ -1315,6 +1315,11 @@ SILCloner<ImplClass>::visitDebugValueInst(DebugValueInst *Inst) {
   remapDebugVarInfo(DebugVarCarryingInst(NewInst));
   recordClonedInstruction(Inst, NewInst);
 }
+template<typename ImplClass>
+void
+SILCloner<ImplClass>::visitDebugStepInst(DebugStepInst *Inst) {
+  recordClonedInstruction(Inst, getBuilder().createDebugStep(Inst->getLoc()));
+}
 
 #define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...)                    \
   template <typename ImplClass>                                                \

include/swift/SIL/SILInstruction.h

@@ -4929,6 +4929,19 @@ class MarkFunctionEscapeInst final
   }
 };
 
+/// This instruction is inserted by Onone optimizations as a replacement for deleted
+/// instructions to ensure that it's possible to set a breakpoint on its location.
+class DebugStepInst final
+    : public InstructionBase<SILInstructionKind::DebugStepInst, NonValueInstruction> {
+  friend SILBuilder;
+
+  DebugStepInst(SILDebugLocation debugLoc) : InstructionBase(debugLoc) {}
+
+public:
+  ArrayRef<Operand> getAllOperands() const { return {}; }
+  MutableArrayRef<Operand> getAllOperands() { return {}; }
+};
+
 /// Define the start or update to a symbolic variable value (for loadable
 /// types).
 class DebugValueInst final

include/swift/SIL/SILNodes.def

@@ -789,6 +789,8 @@ NON_VALUE_INST(MarkFunctionEscapeInst, mark_function_escape,
                SILInstruction, None, DoesNotRelease)
 NON_VALUE_INST(DebugValueInst, debug_value,
                SILInstruction, None, DoesNotRelease)
+NON_VALUE_INST(DebugStepInst, debug_step,
+               SILInstruction, MayHaveSideEffects, DoesNotRelease)
 NON_VALUE_INST(TestSpecificationInst, test_specification,
                SILInstruction, None, DoesNotRelease)
 #define NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...) \

lib/IRGen/IRGenSIL.cpp

@@ -1194,6 +1194,7 @@ class IRGenSILFunction :
     llvm_unreachable("unimplemented");
   }
   void visitDebugValueInst(DebugValueInst *i);
+  void visitDebugStepInst(DebugStepInst *i);
   void visitRetainValueInst(RetainValueInst *i);
   void visitRetainValueAddrInst(RetainValueAddrInst *i);
   void visitCopyValueInst(CopyValueInst *i);
@@ -5113,6 +5114,17 @@ void IRGenSILFunction::visitDebugValueInst(DebugValueInst *i) {
                                AddrDbgInstrKind(i->getWasMoved()));
 }
 
+void IRGenSILFunction::visitDebugStepInst(DebugStepInst *i) {
+  // Unfortunately there is no LLVM-equivalent of a debug_step instruction.
+  // Also LLVM doesn't provide a plain NOP instruction.
+  // Therefore we have to solve this with inline assembly.
+  // Strictly speaking, this is not architecture independent. But there are
+  // probably few assembly languages which don't use "nop" for nop instructions.
+  auto *AsmFnTy = llvm::FunctionType::get(IGM.VoidTy, {}, false);
+  auto *InlineAsm = llvm::InlineAsm::get(AsmFnTy, "nop", "", true);
+  Builder.CreateAsmCall(InlineAsm, {});
+}
+
 void IRGenSILFunction::visitFixLifetimeInst(swift::FixLifetimeInst *i) {
   if (i->getOperand()->getType().isAddress()) {
     // Just pass in the address to fix lifetime if we have one. We will not do