fix generation of DWARF locations for indirect values

The problem comes from the inconsistency between semantics of <llvm.dbg.value>
and location descriptors defined by DWARF. <llvm.dbg.value> describes the
actual *value*, of a source variable - on the other hand, DWARF location
descriptors focus primarily (with few excepions) on describing the *location*
from which the value can be fetched (the location can be an address
in register file or memory).

Now, DWARF allows for the following location desciptors for the pieces of
variables:
    1. empty location
    2. register location
    3. memory location
    4. implicit location

The situation that was not processed correctly looked like this:

```
call void @llvm.dbg.value(metadata [4096 x i32] addrspace(1)* %0,
                          metadata !1299,
                          metadata !DIExpression(DW_OP_deref))
```

This means that the actual *value* of the source varible !1299 is located
at the address defined by %0. Let's assume %0 is held in a register - then
a proper DWARF location descripor should be of "memory location" type which is
evaluated to the value held in %0. In general case, the respected location
descripor should look like this:

```
    0: DW_OP_reg<N + 16>
    1: DW_OP_const1u <offset in GRF N>
    2: DW_OP_const1u <size in bits of %0>
    3: DW_OP_INTEL_push_bit_piece_stack
```

NOTE_1: Item #3, transforms the original "register location" defined by Item #0
to a "memory location". Such transformations are not possible in the vanilla
DWARF spec, thus we had to opt for intel extensions.

NOTE_2: It seems that we have some level of ambiguity. For example,
I think it is perfectly legal to have this kind of expressions:

```
call void @llvm.dbg.value(metadata i32 %0,
                          metadata !1299,
                          metadata !DIExpression(DW_OP_deref), DW_OP_plus_uconst, 3)
```

Such an expression defines a concrete value. But our current implementaion won't
be able to handle this. From dwarf point of view the respected expression
should be an implicit value. While in reality our backend will emit a
<memory location expression>.
I've added some asserts and diagnostics to detect such cases.

Author: aparshin-intel

IGC/DebugInfo/DwarfCompileUnit.cpp

@@ -202,12 +202,6 @@ int64_t CompileUnit::getDefaultLowerBound() const
     return -1;
 }
 
-static bool HasImplicitLocation(const DbgVariable& var) {
-    if (auto* dbgInst = var.getDbgInst())
-        if (auto* expr = dbgInst->getExpression())
-            return expr->isImplicit();
-    return false;
-}
 /// Check whether the DIE for this MDNode can be shared across CUs.
 static bool isShareableAcrossCUs(llvm::MDNode* D)
 {
@@ -1381,9 +1375,7 @@ void CompileUnit::addSimdLane(IGC::DIEBlock* Block, const DbgVariable& DV,
     {
         // SIMD lane
         const auto* VISAMod = Loc->GetVISAModule();
-        auto varSizeInBits = Loc->IsInMemory()
-            ? Asm->GetPointerSize() * 8
-            : DV.getRegisterValueSizeInBits(DD);
+        auto varSizeInBits = DV.getRegisterValueSizeInBits(DD);
 
         LLVM_DEBUG(dbgs() << "  addSimdLane(varSizeInBits: " << varSizeInBits <<
                    ", simdWidthOffset: " << simdWidthOffset << ", isPacked: " <<
@@ -1586,26 +1578,29 @@ void CompileUnit::addSimdLaneScalar(IGC::DIEBlock* Block, const DbgVariable& DV,
 {
     if (EmitSettings.EnableSIMDLaneDebugging)
     {
-        IGC_ASSERT_MESSAGE(lr->isSpill() == false, "Scalar spilled in scratch space");
+        IGC_ASSERT_MESSAGE(!lr->isSpill(), "Scalar spilled in scratch space");
 
-        auto varSizeInBits = Loc->IsInMemory()
-            ? Asm->GetPointerSize() * 8
-            : DV.getRegisterValueSizeInBits(DD);
+        auto varSizeInBits = DV.getRegisterValueSizeInBits(DD);
         auto offsetInBits = subRegInBytes * 8;
         IGC_ASSERT(offsetInBits / 8 == subRegInBytes);
 
+        if (DD->getEmitterSettings().EnableDebugInfoValidation)
+            DD->getStreamEmitter().verifyRegisterLocationExpr(DV, *DD);
+
         LLVM_DEBUG(dbgs() << "  addSimdLaneScalar(varSizeInBits: " <<
                    varSizeInBits << ", offsetInBits: " << offsetInBits << ")\n");
-        if (isa<llvm::DbgDeclareInst>(DV.getDbgInst()) || HasImplicitLocation(DV))
+        if (DV.currentLocationIsMemoryAddress() ||
+            DV.currentLocationIsImplicit() ||
+            DV.currentLocationIsSimpleIndirectValue())
         {
-            // Pointer or an implicit value of a variable
+            // Pointer, indirect or an implicit value of a variable
             // Note: in case of implicit value we want to put the value of the
-            // bit_piece onto DWARF stack, so implict expression could operatate
+            // bit_piece onto DWARF stack, so expression could operate
             // on it.
             addConstantUValue(Block, offsetInBits);
             addConstantUValue(Block, varSizeInBits);
 
-            LLVM_DEBUG(dbgs() << "  value is pointer or an implicit\n");
+            LLVM_DEBUG(dbgs() << "  value is pointer/indirect or an implicit\n");
             IGC_ASSERT_MESSAGE(varSizeInBits <= 64, "Entries pushed onto DWARF stack are limited to 8 bytes");
 
             addUInt(Block, dwarf::DW_FORM_data1, DW_OP_INTEL_push_bit_piece_stack);
@@ -2623,22 +2618,6 @@ IGC::DIEBlock* CompileUnit::buildGeneral(const DbgVariable& var,
     DIEValue* secondHalfOff = nullptr, *skipOff = nullptr;
     unsigned int offsetTaken = 0, offsetNotTaken = 0, offsetEnd = 0;
 
-    auto EmitExpression = [this](IGC::DIEBlock* Block, const DbgVariable& var) {
-        // Emit DIExpression if it exists
-        if (auto* dbgInst = var.getDbgInst())
-        {
-            if (auto* expr = dbgInst->getExpression())
-            {
-                for (auto elem : expr->getElements())
-                {
-                    auto BF = DIEInteger::BestForm(false, elem);
-                    addUInt(Block, BF, elem);
-                }
-            }
-        }
-        return;
-    };
-
     LLVM_DEBUG(dbgs() << "  building DWARF info for the variable [" << var.getName() << "]\n");
     // locs contains 1 item for SIMD8/SIMD16 kernels describing locations of all channels.
     // locs contains 2 items for SIMD32 kernels. First item has storage mapping for lower 16
@@ -2931,13 +2910,19 @@ IGC::DIEBlock* CompileUnit::buildGeneral(const DbgVariable& var,
                     auto offsetInBits = lrToUse.getGRF().subRegNum * 8;
                     IGC_ASSERT(offsetInBits / 8 == lrToUse.getGRF().subRegNum);
 
+                    if (DD->getEmitterSettings().EnableDebugInfoValidation)
+                        DD->getStreamEmitter().verifyRegisterLocationExpr(var, *DD);
+
                     addRegisterLoc(Block, lrToUse.getGRF().regNum, offset, var.getDbgInst());
 
-                    if (HasImplicitLocation(var))
+                    if (var.currentLocationIsMemoryAddress() ||
+                        var.currentLocationIsImplicit() ||
+                        var.currentLocationIsSimpleIndirectValue())
                     {
                         addConstantUValue(Block, offsetInBits);
                         addConstantUValue(Block, varSizeInBits);
 
+                        LLVM_DEBUG(dbgs() << "  value is pointer/indirect or an implicit\n");
                         IGC_ASSERT_MESSAGE(varSizeInBits <= 64, "Entries pushed onto DWARF stack are limited to 8 bytes");
                         addUInt(Block, dwarf::DW_FORM_data1, DW_OP_INTEL_push_bit_piece_stack);
                     }
@@ -2955,7 +2940,7 @@ IGC::DIEBlock* CompileUnit::buildGeneral(const DbgVariable& var,
                         // Emit GT-relative location expression
                         addGTRelativeLocation(Block, loc);
                         addSimdLaneScalar(Block, var, loc, &lrToUse, subReg);
-                        EmitExpression(Block, var);
+                        var.emitExpression(this, Block);
 
                         break;
                     }
@@ -3002,9 +2987,7 @@ IGC::DIEBlock* CompileUnit::buildGeneral(const DbgVariable& var,
                         unsigned GrfSizeInBits = GrfSizeBytes * 8;
                         IGC_ASSERT(GrfSizeInBits <= std::numeric_limits<uint16_t>::max());
 
-                        unsigned varSizeInBits = loc->IsInMemory()
-                            ? Asm->GetPointerSize() * 8
-                            : var.getRegisterValueSizeInBits(DD);
+                        unsigned varSizeInBits = var.getRegisterValueSizeInBits(DD);
 
                         unsigned varSizeInReg = (loc->IsInMemory() && varSizeInBits < 32)
                                               ? 32
@@ -3033,7 +3016,7 @@ IGC::DIEBlock* CompileUnit::buildGeneral(const DbgVariable& var,
             {
                 LLVM_DEBUG(dbgs() << "  <warning> variable is niether in GRF nor spilled\n");
             }
-            EmitExpression(Block, var);
+            var.emitExpression(this, Block);
 
         }
         firstHalf = false;

IGC/DebugInfo/DwarfDebug.cpp

@@ -31,14 +31,15 @@ See LICENSE.TXT for details.
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCAsmInfo.h"
+#include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/IR/IntrinsicInst.h"
-#include "llvm/MC/MCDwarf.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "common/LLVMWarningsPop.hpp"
 
 #include "DwarfDebug.hpp"
@@ -77,19 +78,12 @@ bool DbgVariable::isBlockByrefVariable() const {
 #endif
 }
 
-// Currently, only DbgDeclare and DbgValue are supported
-static bool IsSupportedDebugInst(const llvm::Instruction* Inst)
-{
-    IGC_ASSERT(Inst);
-    return dyn_cast<DbgValueInst>(Inst) || dyn_cast<DbgDeclareInst>(Inst);
-}
-
 static bool IsDebugInst(const llvm::Instruction* Inst)
 {
     if (!isa<DbgInfoIntrinsic>(Inst))
         return false;
 #ifndef NDEBUG
-    if (!IsSupportedDebugInst(Inst))
+    if (!DbgVariable::IsSupportedDebugInst(Inst))
     {
         LLVM_DEBUG(dbgs() << "WARNING! Unsupported DbgInfo Instruction detected:\n";
                    DbgVariable::dumpDbgInst(Inst));
@@ -100,7 +94,7 @@ static bool IsDebugInst(const llvm::Instruction* Inst)
 
 static const MDNode* GetDebugVariable(const Instruction* Inst)
 {
-    IGC_ASSERT(IsSupportedDebugInst(Inst));
+    IGC_ASSERT(DbgVariable::IsSupportedDebugInst(Inst));
 
     if (const auto* DclInst = dyn_cast<DbgDeclareInst>(Inst))
         return DclInst->getVariable();
@@ -111,6 +105,83 @@ static const MDNode* GetDebugVariable(const Instruction* Inst)
     return nullptr;
 }
 
+bool DbgVariable::IsSupportedDebugInst(const llvm::Instruction* Inst)
+{
+    IGC_ASSERT(Inst);
+    return dyn_cast<DbgValueInst>(Inst) || dyn_cast<DbgDeclareInst>(Inst);
+}
+
+bool DbgVariable::currentLocationIsImplicit() const
+{
+    const auto* DbgInst = getDbgInst();
+    if (!DbgInst)
+        return false;
+    return DbgInst->getExpression()->isImplicit();
+}
+
+bool DbgVariable::currentLocationIsMemoryAddress() const
+{
+    const auto* DbgInst = getDbgInst();
+    if (!DbgInst)
+        return false;
+    return isa<llvm::DbgDeclareInst>(DbgInst);
+}
+
+bool DbgVariable::currentLocationIsSimpleIndirectValue() const
+{
+    if (currentLocationIsImplicit())
+        return false;
+
+    const auto* DbgInst = getDbgInst();
+    if (!isa<llvm::DbgValueInst>(DbgInst))
+        return false;
+    auto* Expr = DbgInst->getExpression();
+
+    // IMPORTANT: changes here should be in sync with DbgVariable::emitExpression
+    Value* IRLocation = IGCLLVM::getVariableLocation(DbgInst);
+    if (!IRLocation->getType()->isPointerTy())
+        return false;
+
+    if (!Expr->startsWithDeref())
+        return false;
+
+    if (!std::all_of(Expr->expr_op_begin(), Expr->expr_op_end(),
+                     [](const auto& DIOp) {
+                        return  DIOp.getOp() == dwarf::DW_OP_deref ||
+                                DIOp.getOp() == dwarf::DW_OP_LLVM_fragment;
+                     }))
+    {
+        // backout if the expression contains something other than deref/fragment
+        return false;
+    }
+
+    return true;
+}
+
+void DbgVariable::emitExpression(CompileUnit* CU, IGC::DIEBlock* Block) const
+{
+    IGC_ASSERT(CU);
+    IGC_ASSERT(Block);
+
+    const auto* DbgInst = getDbgInst();
+    if (!DbgInst)
+        return;
+
+    // Indirect values result in emission DWARF location descriptors of
+    // <memory location> type - the evaluation should result in address,
+    // thus no need for OP_deref.
+    // Currently, our dwarf emitters support only "simple indirect" values.
+    auto Elements = DbgInst->getExpression()->getElements();
+    if (currentLocationIsSimpleIndirectValue())
+        Elements = Elements.slice(1); // drop OP_deref
+
+    for (auto elem : Elements)
+    {
+        auto BF = DIEInteger::BestForm(false, elem);
+        CU->addUInt(Block, BF, elem);
+    }
+}
+
 /// If this type is derived from a base type then return base type size
 /// even if it derived directly or indirectly from Derived Type
 uint64_t DbgVariable::getBasicTypeSize(const DICompositeType* Ty) const

IGC/DebugInfo/DwarfDebug.hpp

@@ -151,7 +151,11 @@ namespace IGC
         DbgVariable* getAbstractVariable() const { return AbsVar; }
 
         const llvm::DbgVariableIntrinsic* getDbgInst() const { return m_pDbgInst; }
-        void setDbgInst(const llvm::DbgVariableIntrinsic* pInst) { m_pDbgInst = pInst; }
+        void setDbgInst(const llvm::DbgVariableIntrinsic* pInst)
+        {
+            IGC_ASSERT(pInst && IsSupportedDebugInst(pInst));
+            m_pDbgInst = pInst;
+        }
 
         /// If this type is derived from a base type then return base type size
         /// even if it derived directly or indirectly from Composite Type
@@ -170,6 +174,25 @@ namespace IGC
         /// storage required
         unsigned getRegisterValueSizeInBits(const DwarfDebug* DD) const;
 
+        bool currentLocationIsImplicit() const;
+        bool currentLocationIsMemoryAddress() const;
+
+        // "Simple Indirect Value" is a dbg.value of the following form:
+        //      llvm.dbg.value(pointer to <whatever>, <nevermind>,
+        //                     !DIExpression(DW_OP_deref, [DW_OP_LLVM_fragment]))
+        // Other types of indirect values are currently not supported.
+        // For example, if we encounter an expression like this:
+        //     call void @llvm.dbg.value(metadata i32* %<whatever>,
+        //          metadata !<nevermind>,
+        //          metadata !DIExpression(DW_OP_deref), DW_OP_plus_uconst, 3)
+        // We won't be able to emit a proper expression, due to limitations
+        // of the current *implementation*. A proper expression should have
+        // DW_OP_stack_value to form a proper location descriptor needed in
+        // this context.
+        bool currentLocationIsSimpleIndirectValue() const;
+
+        void emitExpression(CompileUnit* CU, IGC::DIEBlock* Block) const;
+
         // Translate tag to proper Dwarf tag.
         llvm::dwarf::Tag getTag() const
         {
@@ -202,6 +225,8 @@ namespace IGC
 
         llvm::DIType* getType() const;
 
+
+        static bool IsSupportedDebugInst(const llvm::Instruction* Inst);
         void print(llvm::raw_ostream& O, bool NestedAbstract = false) const;
         static void printDbgInst(llvm::raw_ostream& O,
                                  const llvm::Instruction* Inst,

IGC/DebugInfo/StreamEmitter.cpp

@@ -836,30 +836,59 @@ void StreamEmitter::verifyRegisterLocationSize(const IGC::DbgVariable& VarVal,
         // TODO: implement some sanity checks
         return;
     }
-    std::string ErrMsg;
-    llvm::raw_string_ostream OS(ErrMsg);
-    auto PosBeforeChecks = OS.tell();
-
+    DiagnosticBuff Diag;
     auto DwarfTypeSize = VarVal.getBasicSize(&DD);
     if (DwarfTypeSize != ExpectedSize) {
-        OS << "ValidationFailure [regLocSize] -- DWARF Type Size: " <<
+        Diag.out() << "ValidationFailure [regLocSize] -- DWARF Type Size: " <<
             DwarfTypeSize << ", expected: " << ExpectedSize << "\n";
     }
     if (ExpectedSize > MaxGRFSpaceInBits) {
-        OS << "ValidationFailure [GRFSpace] -- Available GRF space: " <<
+        Diag.out() << "ValidationFailure [GRFSpace] -- Available GRF space: " <<
             MaxGRFSpaceInBits << ", while expected value size: " <<
             ExpectedSize << "\n";
     }
 
     // Dump DbgVariable if errors were reported
-    if (PosBeforeChecks != OS.tell())
-    {
-        VarVal.print(OS);
-        OS << "==============\n";
-        OS.str(); // flush raw_string_stream
+    verificationReport(VarVal, Diag);
+}
+
+void StreamEmitter::verifyRegisterLocationExpr(const DbgVariable& DV,
+                                               const DwarfDebug& DD)
+{
+    if (!GetEmitterSettings().EnableDebugInfoValidation)
+        return;
 
-        ErrorLog.append(ErrMsg);
-        LLVM_DEBUG(dbgs() << ErrMsg);
+    // TODO: add checks for locations other than llvm.dbg.value
+    if (DV.currentLocationIsMemoryAddress())
+        return;
+
+    auto* DbgInst = DV.getDbgInst();
+    if (!isa<llvm::DbgValueInst>(DbgInst))
+        return;
+
+    DiagnosticBuff Diag;
+    if (!DV.currentLocationIsImplicit() &&
+        !DV.currentLocationIsSimpleIndirectValue())
+    {
+        if (DbgInst->getExpression()->isComplex())
+        {
+            Diag.out() << "ValidationFailure [UnexpectedComlexExpression]" <<
+               " for a simple register location\n";
+        }
     }
+    verificationReport(DV, Diag);
 }
 
+void StreamEmitter::verificationReport(const DbgVariable& VarVal,
+                                       DiagnosticBuff& Diag)
+{
+    if (Diag.out().tell() == 0)
+        return;
+
+    VarVal.print(Diag.out());
+    Diag.out() << "==============\n";
+    const auto& ErrMsg = Diag.out().str();
+
+    ErrorLog.append(ErrMsg);
+    LLVM_DEBUG(dbgs() << ErrMsg);
+}