gfxstream: cereal: fix 'None' in gfxstream codegen

Commit e27e41a842 ("vulkan,spirv: update headers") exposed a
flaw in the cerealgenerator.

It modified -- among other things -- the VkDeviceCreateInfo
struct in vk.xml.

In the update, the len="enabledLayerCount,null-terminated"
attribute was removed from the ppEnabledLayerNames member.

The gfxstream code generator processes ppEnabledLayerNames
(which is a const char* const*), it identifies it as an "array of
strings". However, because the len attribute is now missing,
vulkanType.getLengthExpression() returns None.

This leads to errors like:

gfxstream_guest_vk_autogen_impl/gen/goldfish_vk_counting_guest.cpp:642:30:
error: use of undeclared identifier 'None'

     642 |     for (uint32_t i = 0; i < None; ++i)
         |                              ^~~~
   1 error generated.

This patch adds various length access checks to prevent this from
happening.

TEST=m vulkan.ranchu

Reviewed-by: David Gilhooley <djgilhooley@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/40785>

src/gfxstream/codegen/scripts/cereal/counting.py

@@ -370,25 +370,27 @@ class VulkanCountingCodegen(VulkanTypeIterator):
         lenAccessGuard = self.lenAccessorGuard(vulkanType)
 
         self.genCount("sizeof(uint32_t)")
-        if lenAccessGuard is not None:
+        if lenAccess is not None:
-            self.cgen.beginIf(lenAccessGuard)
+            if lenAccessGuard is not None:
-        self.cgen.beginFor("uint32_t i = 0", "i < %s" % lenAccess, "++i")
+                self.cgen.beginIf(lenAccessGuard)
-        self.genCount("sizeof(uint32_t) + (%s[i] ? strlen(%s[i]) : 0)" % (access, access))
+            self.cgen.beginFor("uint32_t i = 0", "i < %s" % lenAccess, "++i")
-        self.cgen.endFor()
+            self.genCount("sizeof(uint32_t) + (%s[i] ? strlen(%s[i]) : 0)" % (access, access))
-        if lenAccessGuard is not None:
+            self.cgen.endFor()
-            self.cgen.endIf()
+            if lenAccessGuard is not None:
+                self.cgen.endIf()
 
     def onStaticArr(self, vulkanType):
         access = self.exprValueAccessor(vulkanType)
         lenAccess = self.lenAccessor(vulkanType)
         lenAccessGuard = self.lenAccessorGuard(vulkanType)
 
-        if lenAccessGuard is not None:
+        if lenAccess is not None:
-            self.cgen.beginIf(lenAccessGuard)
+            if lenAccessGuard is not None:
-        finalLenExpr = "%s * %s" % (lenAccess, self.cgen.sizeofExpr(vulkanType))
+                self.cgen.beginIf(lenAccessGuard)
-        if lenAccessGuard is not None:
+            finalLenExpr = "%s * %s" % (lenAccess, self.cgen.sizeofExpr(vulkanType))
-            self.cgen.endIf()
+            if lenAccessGuard is not None:
-        self.genCount(finalLenExpr)
+                self.cgen.endIf()
+            self.genCount(finalLenExpr)
 
     def onStructExtension(self, vulkanType):
         sTypeParam = copy(vulkanType)

src/gfxstream/codegen/scripts/cereal/deepcopy.py

@@ -155,16 +155,17 @@ class DeepcopyCodegen(VulkanTypeIterator):
         lenAccessLhs = self.lenAccessorLhs(vulkanType)
 
         self.cgen.stmt("%s = nullptr" % accessRhs)
-        self.cgen.beginIf("%s && %s" % (accessLhs, lenAccessLhs))
+        if lenAccessLhs is not None:
+            self.cgen.beginIf("%s && %s" % (accessLhs, lenAccessLhs))
 
-        self.cgen.stmt( \
+            self.cgen.stmt( \
-            "%s = %s->strDupArray(%s, %s)" % \
+                "%s = %s->strDupArray(%s, %s)" % \
-            (accessRhs,
+                (accessRhs,
-             self.poolVarName,
+                 self.poolVarName,
-             accessLhs,
+                 accessLhs,
-             lenAccessLhs))
+                 lenAccessLhs))
 
-        self.cgen.endIf()
+            self.cgen.endIf()
 
     def onStaticArr(self, vulkanType):
         accessLhs = self.exprAccessorValueLhs(vulkanType)

src/gfxstream/codegen/scripts/cereal/handlemap.py

@@ -108,10 +108,11 @@ class HandleMapCodegen(VulkanTypeIterator):
         accessLhs = self.exprAccessor(vulkanType)
         lenAccess = self.lenAccessor(vulkanType)
 
-        self.cgen.stmt("%s->mapHandles_%s(%s%s, %s)" % \
+        if lenAccess is not None:
-            (self.handlemapVarName, vulkanType.typeName,
+            self.cgen.stmt("%s->mapHandles_%s(%s%s, %s)" % \
-             self.makeCastExpr(vulkanType.getForAddressAccess().getForNonConstAccess()),
+                (self.handlemapVarName, vulkanType.typeName,
-             accessLhs, lenAccess))
+                 self.makeCastExpr(vulkanType.getForAddressAccess().getForNonConstAccess()),
+                 accessLhs, lenAccess))
 
     def onStructExtension(self, vulkanType):
         access = self.exprAccessor(vulkanType)

src/gfxstream/codegen/scripts/cereal/marshaling.py

@@ -455,8 +455,9 @@ class VulkanMarshalingCodegen(VulkanTypeIterator):
         lenAccess = self.lenAccessor(vulkanType)
 
         if self.direction == "write":
-            self.cgen.stmt("saveStringArray(%s, %s, %s)" % (self.streamVarName,
+            if lenAccess is not None:
-                                                            access, lenAccess))
+                self.cgen.stmt("saveStringArray(%s, %s, %s)" % (self.streamVarName,
+                                                                access, lenAccess))
         else:
             castExpr = \
                 self.makeCastExpr( \
@@ -468,7 +469,10 @@ class VulkanMarshalingCodegen(VulkanTypeIterator):
     def onStaticArr(self, vulkanType):
         access = self.exprValueAccessor(vulkanType)
         lenAccess = self.lenAccessor(vulkanType)
-        finalLenExpr = "%s * %s" % (lenAccess, self.cgen.sizeofExpr(vulkanType))
+        if lenAccess is not None:
+            finalLenExpr = "%s * %s" % (lenAccess, self.cgen.sizeofExpr(vulkanType))
+        else:
+            finalLenExpr = self.cgen.sizeofExpr(vulkanType)
         self.genStreamCall(vulkanType, access, finalLenExpr)
 
     # Old version VkEncoder may have some sType values conflict with VkDecoder

src/gfxstream/codegen/scripts/cereal/reservedmarshaling.py

@@ -548,25 +548,26 @@ class VulkanReservedMarshalingCodegen(VulkanTypeIterator):
         lenAccessGuard = self.lenAccessorGuard(vulkanType)
 
         if self.direction == "write":
-            self.cgen.beginBlock()
+            if lenAccess is not None:
+                self.cgen.beginBlock()
 
-            self.cgen.stmt("uint32_t c = 0")
+                self.cgen.stmt("uint32_t c = 0")
-            if lenAccessGuard is not None:
+                if lenAccessGuard is not None:
-                self.cgen.beginIf(lenAccessGuard)
+                    self.cgen.beginIf(lenAccessGuard)
-            self.cgen.stmt("c = %s" % (lenAccess))
+                self.cgen.stmt("c = %s" % (lenAccess))
-            if lenAccessGuard is not None:
+                if lenAccessGuard is not None:
+                    self.cgen.endIf()
+                self.genMemcpyAndIncr(self.ptrVar, "(uint32_t*)" ,"&c", "sizeof(uint32_t)", toBe = True, actualSize = 4)
+
+                self.cgen.beginFor("uint32_t i = 0", "i < c", "++i")
+                self.cgen.stmt("uint32_t l = %s ? strlen(%s[i]): 0" % (access, access))
+                self.genMemcpyAndIncr(self.ptrVar, "(uint32_t*)" ,"&l", "sizeof(uint32_t)", toBe = True, actualSize = 4)
+                self.cgen.beginIf("l")
+                self.genMemcpyAndIncr(self.ptrVar, "(char*)", "(%s[i])" % access, "l")
                 self.cgen.endIf()
-            self.genMemcpyAndIncr(self.ptrVar, "(uint32_t*)" ,"&c", "sizeof(uint32_t)", toBe = True, actualSize = 4)
+                self.cgen.endFor()
 
-            self.cgen.beginFor("uint32_t i = 0", "i < c", "++i")
+                self.cgen.endBlock()
-            self.cgen.stmt("uint32_t l = %s ? strlen(%s[i]): 0" % (access, access))
-            self.genMemcpyAndIncr(self.ptrVar, "(uint32_t*)" ,"&l", "sizeof(uint32_t)", toBe = True, actualSize = 4)
-            self.cgen.beginIf("l")
-            self.genMemcpyAndIncr(self.ptrVar, "(char*)", "(%s[i])" % access, "l")
-            self.cgen.endIf()
-            self.cgen.endFor()
-
-            self.cgen.endBlock()
         else:
             castExpr = \
                 self.makeCastExpr( \
@@ -578,8 +579,9 @@ class VulkanReservedMarshalingCodegen(VulkanTypeIterator):
     def onStaticArr(self, vulkanType):
         access = self.exprValueAccessor(vulkanType)
         lenAccess = self.lenAccessor(vulkanType)
-        finalLenExpr = "%s * %s" % (lenAccess, self.cgen.sizeofExpr(vulkanType))
+        if lenAccess is not None:
-        self.genStreamCall(vulkanType, access, finalLenExpr)
+            finalLenExpr = "%s * %s" % (lenAccess, self.cgen.sizeofExpr(vulkanType))
+            self.genStreamCall(vulkanType, access, finalLenExpr)
 
     # Old version VkEncoder may have some sType values conflict with VkDecoder
     # of new versions. For host decoder, it should not carry the incorrect old

src/gfxstream/codegen/scripts/cereal/testing.py

@@ -205,53 +205,55 @@ class VulkanEqualityCodegen(VulkanTypeIterator):
             vulkanType,
             "Mismatch in string array pointer nullness")
 
-        equalLenExpr = self.makeEqualExpr(lenAccessLhs, lenAccessRhs)
+        if lenAccessLhs is not None and lenAccessRhs is not None:
+            equalLenExpr = self.makeEqualExpr(lenAccessLhs, lenAccessRhs)
 
-        self.compareWithConsequence( \
+            self.compareWithConsequence( \
-            equalLenExpr,
+                equalLenExpr,
-            vulkanType, "Lengths not equal in string array")
+                vulkanType, "Lengths not equal in string array")
 
-        self.compareWithConsequence( \
+            self.compareWithConsequence( \
-            equalLenExpr,
+                equalLenExpr,
-            vulkanType, "Lengths not equal in string array")
+                vulkanType, "Lengths not equal in string array")
 
-        self.cgen.beginIf("%s && %s" % (equalLenExpr, bothNotNullExpr))
+            self.cgen.beginIf("%s && %s" % (equalLenExpr, bothNotNullExpr))
 
-        loopVar = "i"
+            loopVar = "i"
-        accessLhs = "*(%s + %s)" % (accessLhs, loopVar)
+            accessLhs = "*(%s + %s)" % (accessLhs, loopVar)
-        accessRhs = "*(%s + %s)" % (accessRhs, loopVar)
+            accessRhs = "*(%s + %s)" % (accessRhs, loopVar)
-        forInit = "uint32_t %s = 0" % loopVar
+            forInit = "uint32_t %s = 0" % loopVar
-        forCond = "%s < (uint32_t)%s" % (loopVar, lenAccessLhs)
+            forCond = "%s < (uint32_t)%s" % (loopVar, lenAccessLhs)
-        forIncr = "++%s" % loopVar
+            forIncr = "++%s" % loopVar
 
-        if lenAccessGuardLhs is not None:
+            if lenAccessGuardLhs is not None:
-            self.cgen.beginIf(lenAccessGuardLhs)
+                self.cgen.beginIf(lenAccessGuardLhs)
 
-        self.cgen.beginFor(forInit, forCond, forIncr)
+            self.cgen.beginFor(forInit, forCond, forIncr)
 
-        self.compareWithConsequence(
+            self.compareWithConsequence(
-            self.makeEqualStringExpr(accessLhs, accessRhs),
+                self.makeEqualStringExpr(accessLhs, accessRhs),
-            vulkanType, "Unequal string in string array")
+                vulkanType, "Unequal string in string array")
 
-        self.cgen.endFor()
+            self.cgen.endFor()
+
+            if lenAccessGuardLhs is not None:
+                self.cgen.endIf()
 
-        if lenAccessGuardLhs is not None:
             self.cgen.endIf()
 
-        self.cgen.endIf()
-
     def onStaticArr(self, vulkanType):
         accessLhs = self.exprAccessorLhs(vulkanType)
         accessRhs = self.exprAccessorRhs(vulkanType)
 
         lenAccessLhs = self.lenAccessorLhs(vulkanType)
 
-        finalLenExpr = "%s * %s" % (lenAccessLhs,
+        if lenAccessLhs is not None:
-                                    self.cgen.sizeofExpr(vulkanType))
+            finalLenExpr = "%s * %s" % (lenAccessLhs,
+                                        self.cgen.sizeofExpr(vulkanType))
 
-        self.compareWithConsequence(
+            self.compareWithConsequence(
-            self.makeEqualBufExpr(accessLhs, accessRhs, finalLenExpr),
+                self.makeEqualBufExpr(accessLhs, accessRhs, finalLenExpr),
-            vulkanType, "Unequal static array")
+                vulkanType, "Unequal static array")
 
     def onStructExtension(self, vulkanType):
         lhs = self.exprAccessorLhs(vulkanType)