Support complex recursive types that use an array of pointers

The use of pointer arrays inside the recursive type leads to the SPIR-V IR, where
the TypePointer is declared after TypeArray. In turn, TypeArray can't handle the
unknown element type, because the info from TypeForwardPointer is not used.

Now the translator stores forward declared IDs to use them in backward
translation. It actually means that the translator "knows" about the type but it
would be handled later.

Original commit:
KhronosGroup/SPIRV-LLVM-Translator@8a0235a

Author: vmaksimo

llvm-spirv/lib/SPIRV/SPIRVReader.cpp

@@ -475,6 +475,12 @@ Type *SPIRVToLLVM::transType(SPIRVType *T, bool IsClassMember) {
         getSPIRVTypeName(kSPIRVTypeName::JointMatrixINTEL, SS.str());
     return mapType(T, getOrCreateOpaquePtrType(M, Name));
   }
+  case OpTypeForwardPointer: {
+    SPIRVTypeForwardPointer *FP =
+        static_cast<SPIRVTypeForwardPointer *>(static_cast<SPIRVEntry *>(T));
+    return mapType(T, transType(static_cast<SPIRVType *>(
+                          BM->getEntry(FP->getPointerId()))));
+  }
 
   default: {
     auto OC = T->getOpCode();

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVModule.cpp

@@ -509,6 +509,7 @@ class SPIRVModuleImpl : public SPIRVModule {
   SPIRVForwardPointerVec ForwardPointerVec;
   SPIRVTypeVec TypeVec;
   SPIRVIdToEntryMap IdEntryMap;
+  SPIRVIdToEntryMap IdTypeForwardMap; // Forward declared IDs
   SPIRVFunctionVector FuncVec;
   SPIRVConstantVector ConstVec;
   SPIRVVariableVec VariableVec;
@@ -706,9 +707,15 @@ SPIRVEntry *SPIRVModuleImpl::addEntry(SPIRVEntry *Entry) {
     } else
       IdEntryMap[Id] = Entry;
   } else {
+    // Collect entries with no ID to de-allocate them at the end.
     // Entry of OpLine will be deleted by std::shared_ptr automatically.
     if (Entry->getOpCode() != OpLine)
       EntryNoId.insert(Entry);
+
+    // Store the known ID of pointer type that would be declared later.
+    if (Entry->getOpCode() == OpTypeForwardPointer)
+      IdTypeForwardMap[static_cast<SPIRVTypeForwardPointer *>(Entry)
+                           ->getPointerId()] = Entry;
   }
 
   Entry->setModule(this);
@@ -762,8 +769,15 @@ SPIRVId SPIRVModuleImpl::getId(SPIRVId Id, unsigned Increment) {
 SPIRVEntry *SPIRVModuleImpl::getEntry(SPIRVId Id) const {
   assert(Id != SPIRVID_INVALID && "Invalid Id");
   SPIRVIdToEntryMap::const_iterator Loc = IdEntryMap.find(Id);
-  assert(Loc != IdEntryMap.end() && "Id is not in map");
-  return Loc->second;
+  if (Loc != IdEntryMap.end()) {
+    return Loc->second;
+  }
+  SPIRVIdToEntryMap::const_iterator LocFwd = IdTypeForwardMap.find(Id);
+  if (LocFwd != IdTypeForwardMap.end()) {
+    return LocFwd->second;
+  }
+  assert(false && "Id is not in map");
+  return nullptr;
 }
 
 SPIRVExtInstSetKind SPIRVModuleImpl::getBuiltinSet(SPIRVId SetId) const {
@@ -1732,6 +1746,11 @@ class TopologicalSort {
       return true;
     State = Discovered;
     for (SPIRVEntry *Op : E->getNonLiteralOperands()) {
+      if (Op->getOpCode() == OpTypeForwardPointer) {
+        SPIRVEntry *FP = E->getModule()->getEntry(
+            static_cast<SPIRVTypeForwardPointer *>(Op)->getPointerId());
+        Op = FP;
+      }
       if (EntryStateMap[Op] == Visited)
         continue;
       if (visit(Op)) {
@@ -1745,7 +1764,7 @@ class TopologicalSort {
           SPIRVTypePointer *Ptr = static_cast<SPIRVTypePointer *>(E);
           SPIRVModule *BM = E->getModule();
           ForwardPointerSet.insert(BM->add(new SPIRVTypeForwardPointer(
-              BM, Ptr, Ptr->getPointerStorageClass())));
+              BM, Ptr->getId(), Ptr->getPointerStorageClass())));
           return false;
         }
         return true;
@@ -1776,11 +1795,11 @@ class TopologicalSort {
       : ForwardPointerSet(
             16, // bucket count
             [](const SPIRVTypeForwardPointer *Ptr) {
-              return std::hash<SPIRVId>()(Ptr->getPointer()->getId());
+              return std::hash<SPIRVId>()(Ptr->getPointerId());
             },
             [](const SPIRVTypeForwardPointer *Ptr1,
                const SPIRVTypeForwardPointer *Ptr2) {
-              return Ptr1->getPointer()->getId() == Ptr2->getPointer()->getId();
+              return Ptr1->getPointerId() == Ptr2->getPointerId();
             }),
         EntryStateMap([](SPIRVEntry *A, SPIRVEntry *B) -> bool {
           return A->getId() < B->getId();

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVStream.cpp

@@ -121,6 +121,15 @@ template <class T> const SPIRVEncoder &encode(const SPIRVEncoder &O, T V) {
   return O << static_cast<SPIRVWord>(V);
 }
 
+template <>
+const SPIRVEncoder &operator<<(const SPIRVEncoder &O, SPIRVType *P) {
+  if (!P->hasId() && P->getOpCode() == OpTypeForwardPointer)
+    return O << static_cast<SPIRVTypeForwardPointer *>(
+                    static_cast<SPIRVEntry *>(P))
+                    ->getPointerId();
+  return O << P->getId();
+}
+
 #define SPIRV_DEF_ENCDEC(Type)                                                 \
   const SPIRVDecoder &operator>>(const SPIRVDecoder &I, Type &V) {             \
     return decode(I, V);                                                       \

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVStream.h

@@ -193,6 +193,7 @@ template <typename T>
 const SPIRVEncoder &operator<<(const SPIRVEncoder &O, T *P) {
   return O << P->getId();
 }
+template <> const SPIRVEncoder &operator<<(const SPIRVEncoder &O, SPIRVType *P);
 
 template <typename T>
 const SPIRVEncoder &operator<<(const SPIRVEncoder &O, const std::vector<T> &V) {

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVType.cpp

@@ -266,12 +266,11 @@ SPIRVConstant *SPIRVTypeArray::getLength() const {
 _SPIRV_IMP_ENCDEC3(SPIRVTypeArray, Id, ElemType, Length)
 
 void SPIRVTypeForwardPointer::encode(spv_ostream &O) const {
-  getEncoder(O) << Pointer << SC;
+  getEncoder(O) << PointerId << SC;
 }
 
 void SPIRVTypeForwardPointer::decode(std::istream &I) {
   auto Decoder = getDecoder(I);
-  SPIRVId PointerId;
   Decoder >> PointerId >> SC;
 }
 

llvm-spirv/lib/SPIRV/libSPIRV/SPIRVType.h

@@ -274,17 +274,17 @@ class SPIRVTypePointer : public SPIRVType {
 
 class SPIRVTypeForwardPointer : public SPIRVEntryNoId<OpTypeForwardPointer> {
 public:
-  SPIRVTypeForwardPointer(SPIRVModule *M, SPIRVTypePointer *Pointer,
+  SPIRVTypeForwardPointer(SPIRVModule *M, SPIRVId PointerId,
                           SPIRVStorageClassKind SC)
-      : SPIRVEntryNoId(M, 3), Pointer(Pointer), SC(SC) {}
+      : SPIRVEntryNoId(M, 3), PointerId(PointerId), SC(SC) {}
 
   SPIRVTypeForwardPointer()
-      : Pointer(nullptr), SC(StorageClassUniformConstant) {}
+      : PointerId(SPIRVID_INVALID), SC(StorageClassUniformConstant) {}
 
-  SPIRVTypePointer *getPointer() const { return Pointer; }
+  SPIRVId getPointerId() const { return PointerId; }
   _SPIRV_DCL_ENCDEC
 private:
-  SPIRVTypePointer *Pointer;
+  SPIRVId PointerId;
   SPIRVStorageClassKind SC;
 };
 

llvm-spirv/test/transcoding/RecursiveType.ll

@@ -3,34 +3,49 @@
 ; RUN: FileCheck < %t.txt %s --check-prefix=CHECK-SPIRV
 ; RUN: llvm-spirv %t.bc -o %t.spv
 ; RUN: spirv-val %t.spv
+; RUN: llvm-spirv %t.spv -to-text -o %t.spt
+; RUN: FileCheck < %t.spt %s --check-prefix=CHECK-SPIRV
+
 ; RUN: llvm-spirv -r %t.spv -o %t.rev.bc
 ; RUN: llvm-dis < %t.rev.bc | FileCheck %s --check-prefix=CHECK-LLVM
 
+; RUN: llvm-spirv -r %t.spt -spirv-text -o %t.rev.bc
+; RUN: llvm-dis < %t.rev.bc | FileCheck %s --check-prefix=CHECK-LLVM
+
 target datalayout = "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024"
 target triple = "spir-unknown-unknown"
 
 %struct.A = type { i32, %struct.C }
 %struct.C = type { i32, %struct.B }
 %struct.B = type { i32, %struct.A addrspace(4)* }
 %struct.Node = type { %struct.Node addrspace(1)*, i32 }
+%struct.Flag = type { [3 x %struct.Flag addrspace(3)*] }
 
+; CHECK-SPIRV-DAG: 3 TypeForwardPointer [[FlagFwdPtr:[0-9]+]] 4
 ; CHECK-SPIRV-DAG: 3 TypeForwardPointer [[NodeFwdPtr:[0-9]+]] 5
 ; CHECK-SPIRV-DAG: 3 TypeForwardPointer [[AFwdPtr:[0-9]+]] 8
 ; CHECK-SPIRV: 4 TypeInt [[IntID:[0-9]+]] 32 0
 ; CHECK-SPIRV: 4 TypeStruct [[BID:[0-9]+]] {{[0-9]+}} [[AFwdPtr]]
 ; CHECK-SPIRV: 4 TypeStruct [[CID:[0-9]+]] {{[0-9]+}} [[BID]]
 ; CHECK-SPIRV: 4 TypeStruct [[AID:[0-9]+]] {{[0-9]+}} [[CID]]
+
 ; CHECK-SPIRV: 4 TypePointer [[AFwdPtr]] 8 [[AID:[0-9]+]]
 ; CHECK-SPIRV: 4 TypeStruct [[NodeID:[0-9]+]] [[NodeFwdPtr]]
+
 ; CHECK-SPIRV: 4 TypePointer [[NodeFwdPtr]] 5 [[NodeID]]
+; CHECK-SPIRV: 4 TypeArray [[FlagID:[0-9]+]] [[FlagFwdPtr]]
+; CHECK-SPIRV: 3 TypeStruct [[FlagStructID:[0-9]+]] [[FlagID]]
+
+; CHECK-SPIRV: 4 TypePointer [[FlagFwdPtr]] 4 [[FlagStructID]]
 
 ; CHECK-LLVM: %struct.A = type { i32, %struct.C }
 ; CHECK-LLVM: %struct.C = type { i32, %struct.B }
 ; CHECK-LLVM: %struct.B = type { i32, %struct.A addrspace(4)* }
 ; CHECK-LLVM: %struct.Node = type { %struct.Node addrspace(1)*, i32 }
+; CHECK-LLVM: %struct.Flag = type { [3 x %struct.Flag addrspace(3)*] }
 
 ; Function Attrs: nounwind
-define spir_kernel void @test(%struct.A addrspace(1)* %result, %struct.Node addrspace(1)* %node) #0 !kernel_arg_addr_space !1 !kernel_arg_access_qual !2 !kernel_arg_type !3 !kernel_arg_base_type !4 !kernel_arg_type_qual !5 {
+define spir_kernel void @test(%struct.A addrspace(1)* %result, %struct.Node addrspace(1)* %node, %struct.Flag addrspace(1)* %flag) #0 !kernel_arg_addr_space !1 !kernel_arg_access_qual !2 !kernel_arg_type !3 !kernel_arg_base_type !4 !kernel_arg_type_qual !5 {
   ret void
 }