opt: Fix ADCE DebugDeclare DebugValue treatment (KhronosGroup#6179)

Author: SteveUrquhart

source/opt/aggressive_dead_code_elim_pass.cpp

@@ -44,6 +44,9 @@ constexpr uint32_t kExtInstSetInIdx = 0;
 constexpr uint32_t kExtInstOpInIdx = 1;
 constexpr uint32_t kInterpolantInIdx = 2;
 constexpr uint32_t kCooperativeMatrixLoadSourceAddrInIdx = 0;
+constexpr uint32_t kDebugValueLocalVariable = 2;
+constexpr uint32_t kDebugValueValue = 3;
+constexpr uint32_t kDebugValueExpression = 4;
 
 // Sorting functor to present annotation instructions in an easy-to-process
 // order. The functor orders by opcode first and falls back on unique id
@@ -277,9 +280,53 @@ bool AggressiveDCEPass::AggressiveDCE(Function* func) {
   live_local_vars_.clear();
   InitializeWorkList(func, structured_order);
   ProcessWorkList(func);
+  ProcessDebugInformation(structured_order);
+  ProcessWorkList(func);
   return KillDeadInstructions(func, structured_order);
 }
 
+void AggressiveDCEPass::ProcessDebugInformation(
+    std::list<BasicBlock*>& structured_order) {
+  for (auto bi = structured_order.begin(); bi != structured_order.end(); bi++) {
+    (*bi)->ForEachInst([this](Instruction* inst) {
+      // DebugDeclare is not dead. It must be converted to DebugValue in a
+      // later pass
+      if (inst->IsNonSemanticInstruction() &&
+          inst->GetShader100DebugOpcode() ==
+              NonSemanticShaderDebugInfo100DebugDeclare) {
+        AddToWorklist(inst);
+        return;
+      }
+
+      // If the Value of a DebugValue is killed, set Value operand to Undef
+      if (inst->IsNonSemanticInstruction() &&
+          inst->GetShader100DebugOpcode() ==
+              NonSemanticShaderDebugInfo100DebugValue) {
+        uint32_t id = inst->GetSingleWordInOperand(kDebugValueValue);
+        auto def = get_def_use_mgr()->GetDef(id);
+        if (!live_insts_.Set(def->unique_id())) {
+          AddToWorklist(inst);
+          context()->get_def_use_mgr()->UpdateDefUse(inst);
+          worklist_.push(def);
+          def->SetOpcode(spv::Op::OpUndef);
+          def->SetInOperands({});
+          id = inst->GetSingleWordInOperand(kDebugValueLocalVariable);
+          auto localVar = get_def_use_mgr()->GetDef(id);
+          AddToWorklist(localVar);
+          context()->get_def_use_mgr()->UpdateDefUse(localVar);
+          AddOperandsToWorkList(localVar);
+          context()->get_def_use_mgr()->UpdateDefUse(def);
+          id = inst->GetSingleWordInOperand(kDebugValueExpression);
+          auto expression = get_def_use_mgr()->GetDef(id);
+          AddToWorklist(expression);
+          context()->get_def_use_mgr()->UpdateDefUse(expression);
+          return;
+        }
+      }
+    });
+  }
+}
+
 bool AggressiveDCEPass::KillDeadInstructions(
     const Function* func, std::list<BasicBlock*>& structured_order) {
   bool modified = false;

source/opt/aggressive_dead_code_elim_pass.h

@@ -150,6 +150,12 @@ class AggressiveDCEPass : public MemPass {
   // will be empty at the end.
   void ProcessWorkList(Function* func);
 
+  // Process each DebugDeclare and DebugValue in |func| that has not been
+  // marked as live in the work list. DebugDeclare's are marked live now, and
+  // DebugValue Value operands are set to OpUndef.  The work list will be empty
+  // at the end.
+  void ProcessDebugInformation(std::list<BasicBlock*>& structured_order);
+
   // Kills any instructions in |func| that have not been marked as live.
   bool KillDeadInstructions(const Function* func,
                             std::list<BasicBlock*>& structured_order);

source/opt/instruction.cpp

@@ -1035,6 +1035,12 @@ bool Instruction::IsOpcodeSafeToDelete() const {
     return true;
   }
 
+  if (IsNonSemanticInstruction() &&
+      (GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugDeclare ||
+       GetShader100DebugOpcode() == NonSemanticShaderDebugInfo100DebugValue)) {
+    return true;
+  }
+
   switch (opcode()) {
     case spv::Op::OpDPdx:
     case spv::Op::OpDPdy: