Fix translation of arrays from SPIRV

Lower bounds for every dimension follow counts for every dimension.
Count and lower bound are optional for every dimension
and possibly runtime-calculated.

Author: PiotrFusik

IGC/AdaptorOCL/SPIRV/SPIRVReader.cpp

@@ -575,6 +575,36 @@ class SPIRVToLLVMDbgTran {
 
   DIType* createMember(SPIRVExtInst* inst);
 
+  Metadata* createArrayBound(SPIRVId id, int64_t& intResult)
+  {
+      SPIRVEntry* e = BM->get<SPIRVEntry>(id);
+      switch (e->getOpCode())
+      {
+      case OpConstant:
+          intResult = static_cast<SPIRVConstant*>(e)->getZExtIntValue();
+          return nullptr;
+      case OpExtInst:
+          {
+              SPIRVExtInst* ext = static_cast<SPIRVExtInst*>(e);
+              switch (ext->getExtOp())
+              {
+              case OCLExtOpDbgKind::DebugInfoNone:
+                  return nullptr;
+              case OCLExtOpDbgKind::LocalVariable:
+                  return createLocalVar(ext);
+              case OCLExtOpDbgKind::DbgExpr:
+                  return createExpression(ext);
+              default:
+                  llvm_unreachable("Unknown array bound");
+                  return nullptr;
+              }
+          }
+      default:
+          llvm_unreachable("Unknown array bound");
+          return nullptr;
+      }
+  }
+
   DIType* createTypeArray(SPIRVExtInst* inst)
   {
       if (auto n = getExistingNode<DIType*>(inst))
@@ -584,23 +614,40 @@ class SPIRVToLLVMDbgTran {
 
       auto baseType = createType(BM->get<SPIRVExtInst>(arrayType.getBaseType()));
       auto numDims = arrayType.getNumDims();
-
       SmallVector<llvm::Metadata *, 8> subscripts;
-      uint64_t totalCount = 1;
+      uint64_t totalBits = getSizeInBits(baseType);
 
-      for (unsigned int i = 0; i != numDims; i++)
+      for (unsigned int i = 0; i < numDims; i++)
       {
-          SPIRVConstant* c = BM->get<SPIRVConstant>(arrayType.getComponentCount(i));
-          auto val = c->getZExtIntValue();
-          c = BM->get<SPIRVConstant>(arrayType.getComponentCount(numDims - 1));
-          auto lowerBound = c->getZExtIntValue();
-          subscripts.push_back(Builder.getOrCreateSubrange(lowerBound, val));
-          totalCount *= (uint64_t)(val);
+          int64_t loConst = 0;
+          Metadata* loExpr = arrayType.hasLowerBounds() ? createArrayBound(arrayType.getDimLowerBound(i), loConst) : nullptr;
+
+          int64_t countConst = 0;
+          Metadata* countExpr = createArrayBound(arrayType.getDimCount(i), countConst);
+
+          DISubrange* subrange;
+          (void) loExpr;
+#if LLVM_VERSION_MAJOR >= 11
+          if (loExpr)
+          {
+              if (countConst > 0)
+              {
+                  totalBits *= static_cast<uint64_t>(countConst);
+                  countExpr = ConstantAsMetadata::get(ConstantInt::get(Type::getInt64Ty(M->getContext()), countConst));
+              }
+              subrange = Builder.getOrCreateSubrange(nullptr, loExpr, countExpr, nullptr);
+          }
+          else
+#endif
+          if (countConst > 0)
+              subrange = Builder.getOrCreateSubrange(loConst, countConst);
+          else
+              subrange = Builder.getOrCreateSubrange(loConst, countExpr);
+          subscripts.push_back(subrange);
       }
 
       DINodeArray subscriptArray = Builder.getOrCreateArray(subscripts);
-
-      return addMDNode(inst, Builder.createArrayType(totalCount * getSizeInBits(baseType), 0, baseType, subscriptArray));
+      return addMDNode(inst, Builder.createArrayType(totalBits, 0, baseType, subscriptArray));
   }
 
   DIType* createTypeVector(SPIRVExtInst* inst)

IGC/AdaptorOCL/SPIRV/libSPIRV/SPIRVDebugInfoExt.h

@@ -824,36 +824,34 @@ namespace igc_spv {
     class OpDebugInfoBase
     {
     public:
-        OpDebugInfoBase(SPIRVExtInst* i)
+        OpDebugInfoBase(SPIRVExtInst* i) : extInst(i)
         {
-            extInst = i;
         }
-        bool isOpDebugInfo() { return true; }
 
     protected:
-        SPIRVExtInst* extInst = nullptr;
+        SPIRVExtInst* const extInst;
         template <typename T>
-        T arg(unsigned int id)
+        T arg(unsigned int id) const
         {
             return static_cast<T>(extInst->getArguments()[id]);
         }
-        SPIRVString* str(SPIRVId id)
+        SPIRVString* str(SPIRVId id) const
         {
             auto item = extInst->getModule()->getEntry(arg<SPIRVId>(id));
             if (item->isString())
                 return static_cast<SPIRVString*>(item);
             else
                 return nullptr;
         }
-        uint64_t const_val(SPIRVId id)
+        uint64_t const_val(SPIRVId id) const
         {
             auto item = extInst->getModule()->getEntry(arg<SPIRVId>(id));
             if (item->isConstant())
                 return static_cast<SPIRVConstant*>(item)->getZExtIntValue();
             else
                 return (uint64_t)-1;
         }
-        unsigned int getNumArgs() { return extInst->getArguments().size(); }
+        unsigned int getNumArgs() const { return extInst->getArguments().size(); }
     };
 
     class OpCompilationUnit : OpDebugInfoBase
@@ -988,9 +986,24 @@ namespace igc_spv {
     {
     public:
         OpDebugTypeArray(SPIRVExtInst* extInst) : OpDebugInfoBase(extInst) {}
-        SPIRVId getBaseType() { return arg<SPIRVId>(SPIRVDebug::Operand::TypeArray::BaseTypeIdx); }
-        SPIRVWord getNumDims() { return (getNumArgs() - SPIRVDebug::Operand::TypeArray::ComponentCountIdx); }
-        SPIRVId getComponentCount(unsigned int i) { return arg<SPIRVId>(i + SPIRVDebug::Operand::TypeArray::ComponentCountIdx); }
+        SPIRVId getBaseType() const { return arg<SPIRVId>(SPIRVDebug::Operand::TypeArray::BaseTypeIdx); }
+        bool hasLowerBounds() const
+        {
+            return (getNumArgs() - SPIRVDebug::Operand::TypeArray::ComponentCountIdx) % 2 == 0;
+        }
+        SPIRVWord getNumDims() const
+        {
+            unsigned int n = getNumArgs() - SPIRVDebug::Operand::TypeArray::ComponentCountIdx;
+            return hasLowerBounds() ? n / 2 : n;
+        }
+        SPIRVId getDimCount(unsigned int i) const { return arg<SPIRVId>(SPIRVDebug::Operand::TypeArray::ComponentCountIdx + i); }
+        SPIRVId getDimLowerBound(unsigned int i) const
+        {
+            if (hasLowerBounds()) {
+                return arg<SPIRVId>(SPIRVDebug::Operand::TypeArray::ComponentCountIdx + getNumDims() + i);
+            }
+            return SPIRVID_INVALID;
+        }
     };
 
     class OpDebugTypeVector : OpDebugInfoBase