Code-sinking optimization ignores debug instructions.

As result debug information could become inconsistent, but
some following analyzes take into account debug instructions
and due to the inconsistency they produce incorrect results.
The fix resolves the issue, the optimization move debug
instructions after defining instructions.

Change-Id: Iba1017854e9f2f6325b18a8c28d842b42f3bb2b0

Author: ViacheslavRb

IGC/Compiler/CISACodeGen/CodeSinking.cpp

@@ -432,6 +432,9 @@ namespace IGC {
                 }
             }
         }
+        if (madeChange) {
+            ProcessDbgValueInst(blk);
+        }
 
         return madeChange;
     }
@@ -721,6 +724,9 @@ namespace IGC {
                 }
             }
         }
+        if (madeChange) {
+            ProcessDbgValueInst(*blk);
+        }
         return madeChange;
     }
 
@@ -1104,6 +1110,10 @@ namespace IGC {
 
             bool t = LoopSinkInstructions(sinkCandidates, L);
             changed |= t;
+
+            if (changed) {
+                ProcessDbgValueInst(*Preheader);
+            }
         }
 
         // Invoke LocalSink() to move def to its first use
@@ -1298,5 +1308,40 @@ namespace IGC {
         return changed;
     }
 
+    // Move referenced DbgValueInst intrinsics calls after defining instructions
+    // it is requared for correct work of LiveVariables analysis and other
+    void CodeSinking::ProcessDbgValueInst(BasicBlock& blk)
+    {
+        if (!CTX->m_instrTypes.hasDebugInfo)
+        {
+            return;
+        }
+
+        BasicBlock::iterator I = blk.end();
+        --I;
+        bool processedBegin = false;
+        do {
+            Instruction* inst = cast<Instruction>(I);
+            processedBegin = (I == blk.begin());
+            if (!processedBegin)
+                --I;
+
+            if (auto* DVI = dyn_cast<DbgValueInst>(inst))
+            {
+                if (auto* def = dyn_cast<Instruction>(DVI->getValue()))
+                {
+                    if (!DT->dominates(def, inst))
+                    {
+                        auto* instClone = inst->clone();
+                        instClone->insertAfter(def);
+                        Value* undef = UndefValue::get(def->getType());
+                        MetadataAsValue* MAV = MetadataAsValue::get(inst->getContext(), ValueAsMetadata::get(undef));
+                        cast<CallInst>(inst)->setArgOperand(0, MAV);
+                    }
+                }
+            }
+        } while (!processedBegin);
+    }
+
     char CodeSinking::ID = 0;
 }

IGC/Compiler/CISACodeGen/CodeSinking.hpp

@@ -151,6 +151,10 @@ namespace IGC {
         bool canLoopSink(llvm::Instruction* I, llvm::Loop* L, llvm::BasicBlock* BB);
         bool LoopSinkInstructions(
             llvm::SmallVector<llvm::Instruction*, 64> sinkCandidates, llvm::Loop* L);
+
+        // Move referencing DbgValueInst intrinsics calls after defining instructions
+        void ProcessDbgValueInst(llvm::BasicBlock& blk);
+
     };
 
 }