vk1.2: Add rootType argument to struct handling functions.

Old Vulkan cereal registry uses 1000218000 for
VK_STURCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE, while Vulkan 1.2
cereal registry (and all the third party clients) use this number
for VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT.
This struct type number conflict may cause problems when
encoding/decoding struct chains containing such structs.

However, the structs above have parent struct requirements as well:
for example, VkImportColorBufferGOOGLE can only be "child" structs
of VkMemoryAllocateInfo, while VkPhysicalDeviceFragmentDensityMapFeaturesEXT
could be child structs of VkDeviceCreateInfo or
VkPhysicalDeviceProperties2. Thus we can use this to distinguish
between different structs.

This adds |rootType| argument to all struct handling functions,
including marshaling/unmarshaling/deepcopy/struct size/etc.
|rootType| will store the type of "root" struct of a Vulkan
struct chain, or "VK_STRUCTURE_TYPE_MAX_ENUM" if uninitialized.

Change-Id: I7fd61470e0339fe174f041a600c7b6c51f88f789

13 files changed, 354 insertions, 131 deletions

diff --git a/registry/vulkan/xml/cereal/common/codegen.py b/registry/vulkan/xml/cereal/common/codegen.py
index eb9651aa..d38ab417 100644
--- a/registry/vulkan/xml/cereal/common/codegen.py
+++ b/registry/vulkan/xml/cereal/common/codegen.py
@@ -14,7 +14,7 @@
 # limitations under the License.
 
 from .vulkantypes import VulkanType, VulkanTypeInfo, VulkanCompoundType, VulkanAPI
-
+from collections import OrderedDict
 from copy import copy
 
 import os
@@ -846,7 +846,7 @@ class VulkanWrapperGenerator(object):
     def __init__(self, module, typeInfo):
         self.module = module
         self.typeInfo = typeInfo
-        self.extensionStructTypes = []
+        self.extensionStructTypes = OrderedDict()
 
     def onBegin(self):
         pass
@@ -865,7 +865,7 @@ class VulkanWrapperGenerator(object):
         if category in ["struct", "union"] and not alias:
             structInfo = self.typeInfo.structs[name]
             if structInfo.structExtendsExpr:
-                self.extensionStructTypes.append(structInfo)
+                self.extensionStructTypes[name] = structInfo
         pass
 
     def onGenStruct(self, typeInfo, name, alias):
@@ -880,7 +880,31 @@ class VulkanWrapperGenerator(object):
     def onGenCmd(self, cmdinfo, name, alias):
         pass
 
-    def emitForEachStructExtension(self, cgen, retType, triggerVar, forEachFunc, autoBreak=True, defaultEmit=None, nullEmit=None):
+    # Below Vulkan structure types may correspond to multiple Vulkan structs
+    # due to a conflict between different Vulkan registries. In order to get
+    # the correct Vulkan struct type, we need to check the type of its "root"
+    # struct as well.
+    ROOT_TYPE_MAPPING = {
+        "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT": {
+            "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2": "VkPhysicalDeviceFragmentDensityMapFeaturesEXT",
+            "VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO": "VkPhysicalDeviceFragmentDensityMapFeaturesEXT",
+            "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO": "VkImportColorBufferGOOGLE",
+            "default": "VkPhysicalDeviceFragmentDensityMapFeaturesEXT",
+        },
+        "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT": {
+            "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2": "VkPhysicalDeviceFragmentDensityMapPropertiesEXT",
+            "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO": "VkImportPhysicalAddressGOOGLE",
+            "default": "VkPhysicalDeviceFragmentDensityMapPropertiesEXT",
+        },
+        "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT": {
+            "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO": "VkRenderPassFragmentDensityMapCreateInfoEXT",
+            "VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2": "VkRenderPassFragmentDensityMapCreateInfoEXT",
+            "VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO": "VkImportBufferGOOGLE",
+            "default": "VkRenderPassFragmentDensityMapCreateInfoEXT",
+        },
+    }
+
+    def emitForEachStructExtension(self, cgen, retType, triggerVar, forEachFunc, autoBreak=True, defaultEmit=None, nullEmit=None, rootTypeVar=None):
         def readStructType(structTypeName, structVarName, cgen):
             cgen.stmt("uint32_t %s = (uint32_t)%s(%s)" % \
                 (structTypeName, "goldfish_vk_struct_type", structVarName))
@@ -909,7 +933,7 @@ class VulkanWrapperGenerator(object):
 
         currFeature = None
 
-        for ext in self.extensionStructTypes:
+        for ext in self.extensionStructTypes.values():
             if not currFeature:
                 cgen.leftline("#ifdef %s" % ext.feature)
                 currFeature = ext.feature
@@ -923,9 +947,27 @@ class VulkanWrapperGenerator(object):
             cgen.line("case %s:" % enum)
             cgen.beginBlock()
 
-            castedAccess = castAsStruct(
-                triggerVar.paramName, ext.name, const=triggerVar.isConst)
-            forEachFunc(ext, castedAccess, cgen)
+            if rootTypeVar is not None and enum in VulkanWrapperGenerator.ROOT_TYPE_MAPPING:
+                cgen.line("switch(%s)" % rootTypeVar.paramName)
+                cgen.beginBlock()
+                kv = VulkanWrapperGenerator.ROOT_TYPE_MAPPING[enum]
+                for k in kv:
+                    v = self.extensionStructTypes[kv[k]]
+                    if k == "default":
+                        cgen.line("%s:" % k)
+                    else:
+                        cgen.line("case %s:" % k)
+                    cgen.beginBlock()
+                    castedAccess = castAsStruct(
+                        triggerVar.paramName, v.name, const=triggerVar.isConst)
+                    forEachFunc(v, castedAccess, cgen)
+                    cgen.line("break;")
+                    cgen.endBlock()
+                cgen.endBlock()
+            else:
+                castedAccess = castAsStruct(
+                    triggerVar.paramName, ext.name, const=triggerVar.isConst)
+                forEachFunc(ext, castedAccess, cgen)
 
             if autoBreak:
                 cgen.stmt("break")
@@ -947,7 +989,7 @@ class VulkanWrapperGenerator(object):
     def emitForEachStructExtensionGeneral(self, cgen, forEachFunc, doFeatureIfdefs=False):
         currFeature = None
 
-        for (i, ext) in enumerate(self.extensionStructTypes):
+        for (i, ext) in enumerate(self.extensionStructTypes.values()):
             if doFeatureIfdefs:
                 if not currFeature:
                     cgen.leftline("#ifdef %s" % ext.feature)
diff --git a/registry/vulkan/xml/cereal/counting.py b/registry/vulkan/xml/cereal/counting.py
index a1663b0f..d8df7780 100644
--- a/registry/vulkan/xml/cereal/counting.py
+++ b/registry/vulkan/xml/cereal/counting.py
@@ -20,13 +20,15 @@ from .common.vulkantypes import \
         VulkanAPI, makeVulkanTypeSimple, iterateVulkanType, VulkanTypeIterator, Atom, FuncExpr, FuncExprVal, FuncLambda
 
 from .wrapperdefs import VulkanWrapperGenerator
-from .wrapperdefs import STRUCT_EXTENSION_PARAM, STRUCT_EXTENSION_PARAM_FOR_WRITE, EXTENSION_SIZE_API_NAME, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME
+from .wrapperdefs import ROOT_TYPE_VAR_NAME, ROOT_TYPE_PARAM
+from .wrapperdefs import STRUCT_EXTENSION_PARAM, STRUCT_EXTENSION_PARAM_FOR_WRITE, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME
 
 class VulkanCountingCodegen(VulkanTypeIterator):
-    def __init__(self, cgen, featureBitsVar, toCountVar, countVar, prefix, forApiOutput = False, mapHandles = True, handleMapOverwrites = False, doFiltering = True):
+    def __init__(self, cgen, featureBitsVar, toCountVar, countVar, rootTypeVar, prefix, forApiOutput=False, mapHandles=True, handleMapOverwrites=False, doFiltering=True):
         self.cgen = cgen
         self.featureBitsVar = featureBitsVar
         self.toCountVar = toCountVar
+        self.rootTypeVar = rootTypeVar
         self.countVar = countVar
         self.prefix = prefix
         self.forApiOutput = forApiOutput
@@ -353,7 +355,8 @@ class VulkanCountingCodegen(VulkanTypeIterator):
         accessWithCast = "%s(%s)" % (self.makeCastExpr(
             self.getTypeForStreaming(vulkanType)), access)
 
-        callParams = [self.featureBitsVar, accessWithCast, self.countVar]
+        callParams = [self.featureBitsVar,
+                      self.rootTypeVar, accessWithCast, self.countVar]
 
         for (bindName, localName) in vulkanType.binds.items():
             callParams.append(self.getEnvAccessExpr(localName))
@@ -400,13 +403,22 @@ class VulkanCountingCodegen(VulkanTypeIterator):
         self.genCount(finalLenExpr)
 
     def onStructExtension(self, vulkanType):
+        sTypeParam = copy(vulkanType)
+        sTypeParam.paramName = "sType"
+
         access = self.exprAccessor(vulkanType)
         sizeVar = "%s_size" % vulkanType.paramName
 
         castedAccessExpr = access
 
+        sTypeAccess = self.exprAccessor(sTypeParam)
+        self.cgen.beginIf("%s == VK_STRUCTURE_TYPE_MAX_ENUM" %
+                          self.rootTypeVar)
+        self.cgen.stmt("%s = %s" % (self.rootTypeVar, sTypeAccess))
+        self.cgen.endIf()
+
         self.cgen.funcCall(None, self.prefix + "extension_struct",
-            [self.featureBitsVar, castedAccessExpr, self.countVar])
+                           [self.featureBitsVar, self.rootTypeVar, castedAccessExpr, self.countVar])
 
 
     def onPointer(self, vulkanType):
@@ -496,6 +508,7 @@ class VulkanCounting(VulkanWrapperGenerator):
         self.countVars = ["toCount", "count"]
         self.countVarType = makeVulkanTypeSimple(False, "size_t", 1, self.countVars[1])
         self.voidType = makeVulkanTypeSimple(False, "void", 0)
+        self.rootTypeVar = ROOT_TYPE_VAR_NAME
 
         self.countingCodegen = \
             VulkanCountingCodegen(
@@ -503,6 +516,7 @@ class VulkanCounting(VulkanWrapperGenerator):
                 self.featureBitsVar,
                 self.countVars[0],
                 self.countVars[1],
+                self.rootTypeVar,
                 self.countingPrefix)
 
         self.knownDefs = {}
@@ -511,6 +525,7 @@ class VulkanCounting(VulkanWrapperGenerator):
             VulkanAPI(self.countingPrefix + "extension_struct",
                       self.voidType,
                       [self.featureBitsVarType,
+                       ROOT_TYPE_PARAM,
                        STRUCT_EXTENSION_PARAM,
                        self.countVarType])
 
@@ -553,6 +568,7 @@ class VulkanCounting(VulkanWrapperGenerator):
 
             countingParams = \
                 [makeVulkanTypeSimple(False, "uint32_t", 0, self.featureBitsVar),
+                 ROOT_TYPE_PARAM,
                  typeFromName(self.countVars[0]),
                  makeVulkanTypeSimple(False, "size_t", 1, self.countVars[1])]
 
@@ -570,6 +586,7 @@ class VulkanCounting(VulkanWrapperGenerator):
                 self.countingCodegen.cgen = cgen
                 self.countingCodegen.currentStructInfo = structInfo
                 cgen.stmt("(void)%s" % self.featureBitsVar);
+                cgen.stmt("(void)%s" % self.rootTypeVar);
                 cgen.stmt("(void)%s" % self.countVars[0]);
                 cgen.stmt("(void)%s" % self.countVars[1]);
 
@@ -588,6 +605,7 @@ class VulkanCounting(VulkanWrapperGenerator):
                 self.countingCodegen.currentStructInfo = structInfo
                 self.countingCodegen.doFiltering = False
                 cgen.stmt("(void)%s" % self.featureBitsVar);
+                cgen.stmt("(void)%s" % self.rootTypeVar);
                 cgen.stmt("(void)%s" % self.countVars[0]);
                 cgen.stmt("(void)%s" % self.countVars[1]);
 
@@ -622,12 +640,14 @@ class VulkanCounting(VulkanWrapperGenerator):
         accessVar = "structAccess"
         sizeVar = "currExtSize"
         cgen.stmt("VkInstanceCreateInfo* %s = (VkInstanceCreateInfo*)(%s)" % (accessVar, extParam.paramName))
-        cgen.stmt("size_t %s = %s(%s, %s)" % (sizeVar, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME, self.featureBitsVar, extParam.paramName))
+        cgen.stmt("size_t %s = %s(%s, %s, %s)" % (sizeVar, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME,
+                                                  self.featureBitsVar, ROOT_TYPE_VAR_NAME, extParam.paramName))
 
         cgen.beginIf("!%s && %s" % (sizeVar, extParam.paramName))
 
         cgen.line("// unknown struct extension; skip and call on its pNext field");
-        cgen.funcCall(None, funcproto.name, [self.featureBitsVar, "(void*)%s->pNext" % accessVar, self.countVars[1]])
+        cgen.funcCall(None, funcproto.name, [
+                      self.featureBitsVar, ROOT_TYPE_VAR_NAME, "(void*)%s->pNext" % accessVar, self.countVars[1]])
         cgen.stmt("return")
 
         cgen.endIf()
@@ -656,14 +676,15 @@ class VulkanCounting(VulkanWrapperGenerator):
             makeVulkanTypeSimple(False, "void", 0, "void"),
             extParam,
             forEach,
-            defaultEmit=fatalDefault)
+            defaultEmit=fatalDefault,
+            rootTypeVar=ROOT_TYPE_PARAM)
 
     def onEnd(self,):
         VulkanWrapperGenerator.onEnd(self)
 
         def forEachExtensionCounting(ext, castedAccess, cgen):
             cgen.funcCall(None, self.countingPrefix + ext.name,
-                          [self.featureBitsVar, castedAccess, self.countVars[1]])
+                          [self.featureBitsVar, self.rootTypeVar, castedAccess, self.countVars[1]])
 
         self.module.appendImpl(
             self.codegen.makeFuncImpl(
diff --git a/registry/vulkan/xml/cereal/decoder.py b/registry/vulkan/xml/cereal/decoder.py
index 41859f58..0987709d 100644
--- a/registry/vulkan/xml/cereal/decoder.py
+++ b/registry/vulkan/xml/cereal/decoder.py
@@ -9,6 +9,7 @@ from .transform import TransformCodegen, genTransformsForVulkanType
 from .wrapperdefs import API_PREFIX_MARSHAL
 from .wrapperdefs import API_PREFIX_UNMARSHAL, API_PREFIX_RESERVEDUNMARSHAL
 from .wrapperdefs import VULKAN_STREAM_TYPE
+from .wrapperdefs import ROOT_TYPE_DEFAULT_VALUE
 from .wrapperdefs import RELAXED_APIS
 
 from copy import copy
@@ -116,6 +117,7 @@ def emit_unmarshal(typeInfo, param, cgen, output = False, destroy = False, noUnb
         iterateVulkanType(typeInfo, param, VulkanReservedMarshalingCodegen(
             cgen,
             READ_STREAM,
+            ROOT_TYPE_DEFAULT_VALUE,
             param.paramName,
             "readStreamPtrPtr",
             API_PREFIX_RESERVEDUNMARSHAL,
@@ -142,6 +144,7 @@ def emit_unmarshal(typeInfo, param, cgen, output = False, destroy = False, noUnb
         iterateVulkanType(typeInfo, param, VulkanReservedMarshalingCodegen(
             cgen,
             READ_STREAM,
+            ROOT_TYPE_DEFAULT_VALUE,
             param.paramName,
             "readStreamPtrPtr",
             API_PREFIX_RESERVEDUNMARSHAL,
@@ -155,6 +158,7 @@ def emit_dispatch_unmarshal(typeInfo, param, cgen, globalWrapped):
         iterateVulkanType(typeInfo, param, VulkanReservedMarshalingCodegen(
             cgen,
             READ_STREAM,
+            ROOT_TYPE_DEFAULT_VALUE,
             param.paramName,
             "readStreamPtrPtr",
             API_PREFIX_RESERVEDUNMARSHAL,
@@ -167,6 +171,7 @@ def emit_dispatch_unmarshal(typeInfo, param, cgen, globalWrapped):
         iterateVulkanType(typeInfo, param, VulkanReservedMarshalingCodegen(
             cgen,
             READ_STREAM,
+            ROOT_TYPE_DEFAULT_VALUE,
             param.paramName,
             "readStreamPtrPtr",
             API_PREFIX_RESERVEDUNMARSHAL,
@@ -190,6 +195,7 @@ def emit_marshal(typeInfo, param, cgen, handleMapOverwrites=False):
     iterateVulkanType(typeInfo, param, VulkanMarshalingCodegen(
         cgen,
         WRITE_STREAM,
+        ROOT_TYPE_DEFAULT_VALUE,
         param.paramName,
         API_PREFIX_MARSHAL,
         direction="write",
diff --git a/registry/vulkan/xml/cereal/decodersnapshot.py b/registry/vulkan/xml/cereal/decodersnapshot.py
index e2dd39bc..fa38e57e 100644
--- a/registry/vulkan/xml/cereal/decodersnapshot.py
+++ b/registry/vulkan/xml/cereal/decodersnapshot.py
@@ -2,7 +2,6 @@ from .common.codegen import CodeGen, VulkanWrapperGenerator, VulkanAPIWrapper
 from .common.vulkantypes import \
         VulkanAPI, makeVulkanTypeSimple, iterateVulkanType, DISPATCHABLE_HANDLE_TYPES, NON_DISPATCHABLE_HANDLE_TYPES
 
-from .marshaling import VulkanMarshalingCodegen
 from .transform import TransformCodegen, genTransformsForVulkanType
 
 from .wrapperdefs import API_PREFIX_MARSHAL
diff --git a/registry/vulkan/xml/cereal/deepcopy.py b/registry/vulkan/xml/cereal/deepcopy.py
index cd7babe8..a6a5cc82 100644
--- a/registry/vulkan/xml/cereal/deepcopy.py
+++ b/registry/vulkan/xml/cereal/deepcopy.py
@@ -21,11 +21,12 @@ from .wrapperdefs import VulkanWrapperGenerator
 from .wrapperdefs import STRUCT_EXTENSION_PARAM, STRUCT_EXTENSION_PARAM_FOR_WRITE, EXTENSION_SIZE_API_NAME
 
 class DeepcopyCodegen(VulkanTypeIterator):
-    def __init__(self, cgen, inputVars, poolVarName, prefix, skipValues=False):
+    def __init__(self, cgen, inputVars, poolVarName, rootVarName, prefix, skipValues=False):
         self.cgen = cgen
         self.inputVars = inputVars
         self.prefix = prefix
         self.poolVarName = poolVarName
+        self.rootVarName = rootVarName
         self.skipValues = skipValues
 
         def makeAccess(varName, asPtr = True):
@@ -133,7 +134,7 @@ class DeepcopyCodegen(VulkanTypeIterator):
         accessRhsCasted = self.makeNonConstCastForCopy(accessRhs, vulkanType)
 
         self.cgen.funcCall(None, self.prefix + vulkanType.typeName,
-                           [self.poolVarName, accessLhs, accessRhsCasted])
+                           [self.poolVarName, self.rootVarName, accessLhs, accessRhsCasted])
 
         if lenAccessLhs is not None:
             self.cgen.endFor()
@@ -196,13 +197,19 @@ class DeepcopyCodegen(VulkanTypeIterator):
         nextVar = "from_%s" % vulkanType.paramName
         sizeVar = "%s_size" % vulkanType.paramName
 
+        self.cgen.beginIf("%s == VK_STRUCTURE_TYPE_MAX_ENUM" %
+                          self.rootVarName)
+        self.cgen.stmt("%s = from->sType" % self.rootVarName)
+        self.cgen.endIf()
+
         self.cgen.stmt("const void* %s = %s" % (nextVar, self.inputVars[0]))
         self.cgen.stmt("size_t %s = 0u" % sizeVar)
         self.cgen.beginWhile("!%s && %s" % (sizeVar, nextVar))
         self.cgen.stmt("%s = static_cast<const vk_struct_common*>(%s)->%s" % (
             nextVar, nextVar, vulkanType.paramName
         ))
-        self.cgen.stmt("%s = %s(%s)" % (sizeVar, EXTENSION_SIZE_API_NAME, nextVar))
+        self.cgen.stmt("%s = %s(%s, %s)" % (
+            sizeVar, EXTENSION_SIZE_API_NAME, self.rootVarName, nextVar))
         self.cgen.endWhile()
         
         self.cgen.stmt("%s = nullptr" % rhs)
@@ -215,7 +222,7 @@ class DeepcopyCodegen(VulkanTypeIterator):
             self.poolVarName, sizeVar))
 
         self.cgen.funcCall(None, self.prefix + "extension_struct",
-                           [self.poolVarName, nextVar, rhsExpr])
+                           [self.poolVarName, self.rootVarName, nextVar, rhsExpr])
 
         self.cgen.endIf()
 
@@ -267,6 +274,10 @@ class VulkanDeepcopy(VulkanWrapperGenerator):
         self.deepcopyPoolParam = \
             makeVulkanTypeSimple(False, "BumpPool", 1,
                                  self.deepcopyPoolVarName)
+        self.deepcopyRootVarName = "rootType"
+        self.deepcopyRootParam = \
+            makeVulkanTypeSimple(False, "VkStructureType",
+                                 0, self.deepcopyRootVarName)
         self.voidType = makeVulkanTypeSimple(False, "void", 0)
 
         self.deepcopyCodegen = \
@@ -274,6 +285,7 @@ class VulkanDeepcopy(VulkanWrapperGenerator):
                 None,
                 self.deepcopyVars,
                 self.deepcopyPoolVarName,
+                self.deepcopyRootVarName,
                 self.deepcopyPrefix,
                 skipValues=True)
 
@@ -283,6 +295,7 @@ class VulkanDeepcopy(VulkanWrapperGenerator):
             VulkanAPI(self.deepcopyPrefix + "extension_struct",
                       self.voidType,
                       [self.deepcopyPoolParam,
+                       self.deepcopyRootParam,
                        STRUCT_EXTENSION_PARAM,
                        STRUCT_EXTENSION_PARAM_FOR_WRITE])
 
@@ -313,8 +326,8 @@ class VulkanDeepcopy(VulkanWrapperGenerator):
                     makeVulkanTypeSimple(varname == "from", name, 1, varname)
 
             deepcopyParams = \
-                [self.deepcopyPoolParam] + \
-                list(map(typeFromName, self.deepcopyVars))
+                [self.deepcopyPoolParam, self.deepcopyRootParam] + \
+                 list(map(typeFromName, self.deepcopyVars))
 
             deepcopyPrototype = \
                 VulkanAPI(self.deepcopyPrefix + name,
@@ -329,6 +342,7 @@ class VulkanDeepcopy(VulkanWrapperGenerator):
                         canSimplyAssign = False
 
                 cgen.stmt("(void)%s" % self.deepcopyPoolVarName)
+                cgen.stmt("(void)%s" % self.deepcopyRootVarName)
                 cgen.stmt("*to = *from")
                 if canSimplyAssign:
                     pass
@@ -356,6 +370,7 @@ class VulkanDeepcopy(VulkanWrapperGenerator):
         def forEachExtensionDeepcopy(ext, castedAccess, cgen):
             cgen.funcCall(None, self.deepcopyPrefix + ext.name,
                           [self.deepcopyPoolVarName,
+                           self.deepcopyRootVarName,
                            castedAccess, deepcopyDstExpr(cgen, ext.name)])
 
         self.module.appendImpl(
@@ -365,4 +380,5 @@ class VulkanDeepcopy(VulkanWrapperGenerator):
                     cgen,
                     self.voidType,
                     STRUCT_EXTENSION_PARAM,
-                    forEachExtensionDeepcopy)))
+                    forEachExtensionDeepcopy,
+                    rootTypeVar=self.deepcopyRootParam)))
diff --git a/registry/vulkan/xml/cereal/encoder.py b/registry/vulkan/xml/cereal/encoder.py
index 8668cd25..337dddce 100644
--- a/registry/vulkan/xml/cereal/encoder.py
+++ b/registry/vulkan/xml/cereal/encoder.py
@@ -14,6 +14,7 @@ from .transform import TransformCodegen, genTransformsForVulkanType
 from .wrapperdefs import API_PREFIX_RESERVEDMARSHAL
 from .wrapperdefs import API_PREFIX_MARSHAL
 from .wrapperdefs import API_PREFIX_UNMARSHAL
+from .wrapperdefs import ROOT_TYPE_DEFAULT_VALUE
 from .wrapperdefs import VULKAN_STREAM_TYPE_GUEST
 
 encoder_decl_preamble = """
@@ -157,7 +158,7 @@ def emit_count_marshal(typeInfo, param, cgen):
         iterateVulkanType(
             typeInfo, param,
             VulkanCountingCodegen( \
-               cgen, "sFeatureBits", param.paramName, "countPtr",
+                cgen, "sFeatureBits", param.paramName, "countPtr", ROOT_TYPE_DEFAULT_VALUE,
                "count_"))
     if not res:
         cgen.stmt("(void)%s" % param.paramName)
@@ -171,7 +172,7 @@ def emit_marshal(typeInfo, param, cgen):
         iterateVulkanType(
             typeInfo, param,
             VulkanReservedMarshalingCodegen( \
-               cgen, STREAM, param.paramName, "streamPtrPtr",
+                cgen, STREAM, ROOT_TYPE_DEFAULT_VALUE, param.paramName, "streamPtrPtr",
                API_PREFIX_RESERVEDMARSHAL,
                "" if forOutput else "get_host_u64_",
                direction="write"))
@@ -185,13 +186,13 @@ def emit_unmarshal(typeInfo, param, cgen):
     iterateVulkanType(
         typeInfo, param,
         VulkanMarshalingCodegen( \
-           cgen, STREAM, param.paramName,
+            cgen, STREAM, ROOT_TYPE_DEFAULT_VALUE, param.paramName,
            API_PREFIX_UNMARSHAL, direction="read"))
 
 def emit_deepcopy(typeInfo, param, cgen):
     res = \
         iterateVulkanType(typeInfo, param, DeepcopyCodegen(
-            cgen, [param.paramName, "local_" + param.paramName], "pool", "deepcopy_"))
+            cgen, [param.paramName, "local_" + param.paramName], "pool", ROOT_TYPE_DEFAULT_VALUE, "deepcopy_"))
     if not res:
         cgen.stmt("(void)%s" % param.paramName)
 
diff --git a/registry/vulkan/xml/cereal/extensionstructs.py b/registry/vulkan/xml/cereal/extensionstructs.py
index 99b66e9e..95c95237 100644
--- a/registry/vulkan/xml/cereal/extensionstructs.py
+++ b/registry/vulkan/xml/cereal/extensionstructs.py
@@ -33,6 +33,11 @@ class VulkanExtensionStructs(VulkanWrapperGenerator):
 
         self.structTypeRetType = \
             makeVulkanTypeSimple(False, "uint32_t", 0)
+
+        self.rootTypeVarName = "rootType"
+        self.rootTypeParam = \
+            makeVulkanTypeSimple(False, "VkStructureType",
+                                 0, self.rootTypeVarName)
         self.structTypePrototype = \
             VulkanAPI(STRUCT_TYPE_API_NAME,
                       self.structTypeRetType,
@@ -43,14 +48,14 @@ class VulkanExtensionStructs(VulkanWrapperGenerator):
         self.extensionStructSizePrototype = \
             VulkanAPI(EXTENSION_SIZE_API_NAME,
                       self.extensionStructSizeRetType,
-                      [STRUCT_EXTENSION_PARAM])
+                      [self.rootTypeParam, STRUCT_EXTENSION_PARAM])
 
         self.streamFeaturesType = makeVulkanTypeSimple(False, "uint32_t", 0, "streamFeatures")
 
         self.extensionStructSizeWithStreamFeaturesPrototype = \
             VulkanAPI(EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME,
                       self.extensionStructSizeRetType,
-                      [self.streamFeaturesType, STRUCT_EXTENSION_PARAM])
+                      [self.streamFeaturesType, self.rootTypeParam, STRUCT_EXTENSION_PARAM])
     def onBegin(self,):
         VulkanWrapperGenerator.onBegin(self)
         self.module.appendHeader(self.codegen.makeFuncDecl(
@@ -106,7 +111,8 @@ class VulkanExtensionStructs(VulkanWrapperGenerator):
                     cgen,
                     self.extensionStructSizeRetType,
                     STRUCT_EXTENSION_PARAM,
-                    forEachExtensionReturnSize, autoBreak=False)))
+                    forEachExtensionReturnSize, autoBreak=False,
+                    rootTypeVar=self.rootTypeParam)))
 
         self.module.appendImpl(
             self.codegen.makeFuncImpl(
@@ -115,4 +121,5 @@ class VulkanExtensionStructs(VulkanWrapperGenerator):
                     cgen,
                     self.extensionStructSizeRetType,
                     STRUCT_EXTENSION_PARAM,
-                    forEachExtensionReturnSizeProtectedByFeature, autoBreak=False)))
+                    forEachExtensionReturnSizeProtectedByFeature, autoBreak=False,
+                    rootTypeVar=self.rootTypeParam)))
diff --git a/registry/vulkan/xml/cereal/marshaling.py b/registry/vulkan/xml/cereal/marshaling.py
index 05bebe7e..25a78d68 100644
--- a/registry/vulkan/xml/cereal/marshaling.py
+++ b/registry/vulkan/xml/cereal/marshaling.py
@@ -22,12 +22,14 @@ from .common.vulkantypes import \
 
 from .wrapperdefs import VulkanWrapperGenerator
 from .wrapperdefs import VULKAN_STREAM_VAR_NAME
+from .wrapperdefs import ROOT_TYPE_VAR_NAME, ROOT_TYPE_PARAM
 from .wrapperdefs import STREAM_RET_TYPE
 from .wrapperdefs import MARSHAL_INPUT_VAR_NAME
 from .wrapperdefs import UNMARSHAL_INPUT_VAR_NAME
 from .wrapperdefs import PARAMETERS_MARSHALING
 from .wrapperdefs import PARAMETERS_MARSHALING_GUEST
-from .wrapperdefs import STRUCT_EXTENSION_PARAM, STRUCT_EXTENSION_PARAM_FOR_WRITE, EXTENSION_SIZE_API_NAME, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME
+from .wrapperdefs import STYPE_OVERRIDE
+from .wrapperdefs import STRUCT_EXTENSION_PARAM, STRUCT_EXTENSION_PARAM_FOR_WRITE, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME
 from .wrapperdefs import API_PREFIX_MARSHAL
 from .wrapperdefs import API_PREFIX_UNMARSHAL
 
@@ -38,6 +40,7 @@ class VulkanMarshalingCodegen(VulkanTypeIterator):
     def __init__(self,
                  cgen,
                  streamVarName,
+                 rootTypeVarName,
                  inputVarName,
                  marshalPrefix,
                  direction = "write",
@@ -54,6 +57,7 @@ class VulkanMarshalingCodegen(VulkanTypeIterator):
         self.checked = False
 
         self.streamVarName = streamVarName
+        self.rootTypeVarName = rootTypeVarName
         self.inputVarName = inputVarName
         self.marshalPrefix = marshalPrefix
 
@@ -423,7 +427,7 @@ class VulkanMarshalingCodegen(VulkanTypeIterator):
         accessWithCast = "%s(%s)" % (self.makeCastExpr(
             self.getTypeForStreaming(vulkanType)), access)
 
-        callParams = [self.streamVarName, accessWithCast]
+        callParams = [self.streamVarName, self.rootTypeVarName, accessWithCast]
 
         for (bindName, localName) in vulkanType.binds.items():
             callParams.append(self.getEnvAccessExpr(localName))
@@ -478,7 +482,27 @@ class VulkanMarshalingCodegen(VulkanTypeIterator):
         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
+    # sType values to the |forUnmarshaling| struct. Instead it should overwrite
+    # the sType value.
+    def overwriteSType(self, vulkanType):
+        if self.direction == "read":
+            sTypeParam = copy(vulkanType)
+            sTypeParam.paramName = "sType"
+            sTypeAccess = self.exprAccessor(sTypeParam)
+
+            typeName = vulkanType.parent.typeName
+            if typeName in STYPE_OVERRIDE:
+                self.cgen.stmt("%s = %s" %
+                               (sTypeAccess, STYPE_OVERRIDE[typeName]))
+
     def onStructExtension(self, vulkanType):
+        self.overwriteSType(vulkanType)
+
+        sTypeParam = copy(vulkanType)
+        sTypeParam.paramName = "sType"
+
         access = self.exprAccessor(vulkanType)
         sizeVar = "%s_size" % vulkanType.paramName
 
@@ -487,6 +511,12 @@ class VulkanMarshalingCodegen(VulkanTypeIterator):
         else:
             castedAccessExpr = access
 
+        sTypeAccess = self.exprAccessor(sTypeParam)
+        self.cgen.beginIf("%s == VK_STRUCTURE_TYPE_MAX_ENUM" %
+                          self.rootTypeVarName)
+        self.cgen.stmt("%s = %s" % (self.rootTypeVarName, sTypeAccess))
+        self.cgen.endIf()
+
         if self.direction == "read" and self.dynAlloc:
             self.cgen.stmt("size_t %s" % sizeVar)
             self.cgen.stmt("%s = %s->getBe32()" % \
@@ -500,17 +530,17 @@ class VulkanMarshalingCodegen(VulkanTypeIterator):
             self.genStreamCall(vulkanType, access, "sizeof(VkStructureType)")
             self.cgen.stmt("VkStructureType extType = *(VkStructureType*)(%s)" % access)
             self.cgen.stmt( \
-                    "%s->alloc((void**)&%s, %s(%s->getFeatureBits(), %s))" %
-                    (self.streamVarName, access, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME, self.streamVarName, access))
+                "%s->alloc((void**)&%s, %s(%s->getFeatureBits(), %s, %s))" %
+                (self.streamVarName, access, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME, self.streamVarName, self.rootTypeVarName, access))
             self.cgen.stmt("*(VkStructureType*)%s = extType" % access)
 
             self.cgen.funcCall(None, self.marshalPrefix + "extension_struct",
-                [self.streamVarName, castedAccessExpr])
+                               [self.streamVarName, self.rootTypeVarName, castedAccessExpr])
             self.cgen.endIf()
         else:
 
             self.cgen.funcCall(None, self.marshalPrefix + "extension_struct",
-                [self.streamVarName, castedAccessExpr])
+                               [self.streamVarName, self.rootTypeVarName, castedAccessExpr])
 
 
     def onPointer(self, vulkanType):
@@ -609,6 +639,7 @@ class VulkanMarshaling(VulkanWrapperGenerator):
             VulkanMarshalingCodegen(
                 None,
                 VULKAN_STREAM_VAR_NAME,
+                ROOT_TYPE_VAR_NAME,
                 MARSHAL_INPUT_VAR_NAME,
                 API_PREFIX_MARSHAL,
                 direction = "write")
@@ -617,6 +648,7 @@ class VulkanMarshaling(VulkanWrapperGenerator):
             VulkanMarshalingCodegen(
                 None,
                 VULKAN_STREAM_VAR_NAME,
+                ROOT_TYPE_VAR_NAME,
                 UNMARSHAL_INPUT_VAR_NAME,
                 API_PREFIX_UNMARSHAL,
                 direction = "read",
@@ -701,10 +733,13 @@ class VulkanMarshaling(VulkanWrapperGenerator):
             def structMarshalingCustom(cgen):
                 self.writeCodegen.cgen = cgen
                 self.writeCodegen.currentStructInfo = structInfo
+                self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
+
                 marshalingCode = \
                     CUSTOM_MARSHAL_TYPES[name]["common"] + \
                     CUSTOM_MARSHAL_TYPES[name]["marshaling"].format(
                         streamVarName=self.writeCodegen.streamVarName, 
+                        rootTypeVarName=self.writeCodegen.rootTypeVarName,
                         inputVarName=self.writeCodegen.inputVarName,
                         newInputVarName=self.writeCodegen.inputVarName + "_new")
                 for line in marshalingCode.split('\n'):
@@ -713,6 +748,7 @@ class VulkanMarshaling(VulkanWrapperGenerator):
             def structMarshalingDef(cgen):
                 self.writeCodegen.cgen = cgen
                 self.writeCodegen.currentStructInfo = structInfo
+                self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
 
                 if category == "struct":
                     # marshal 'let' parameters first
@@ -728,6 +764,8 @@ class VulkanMarshaling(VulkanWrapperGenerator):
                 self.writeCodegen.cgen = cgen
                 self.writeCodegen.currentStructInfo = structInfo
                 self.writeCodegen.doFiltering = False
+                self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
+
                 if category == "struct":
                     # marshal 'let' parameters first
                     for letp in letParams:
@@ -771,10 +809,13 @@ class VulkanMarshaling(VulkanWrapperGenerator):
             def structUnmarshalingCustom(cgen):
                 self.readCodegen.cgen = cgen
                 self.readCodegen.currentStructInfo = structInfo
+                self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
+
                 unmarshalingCode = \
                     CUSTOM_MARSHAL_TYPES[name]["common"] + \
                     CUSTOM_MARSHAL_TYPES[name]["unmarshaling"].format(
-                        streamVarName=self.readCodegen.streamVarName, 
+                        streamVarName=self.readCodegen.streamVarName,
+                        rootTypeVarName=self.readCodegen.rootTypeVarName,
                         inputVarName=self.readCodegen.inputVarName,
                         newInputVarName=self.readCodegen.inputVarName + "_new")
                 for line in unmarshalingCode.split('\n'):
@@ -783,6 +824,8 @@ class VulkanMarshaling(VulkanWrapperGenerator):
             def structUnmarshalingDef(cgen):
                 self.readCodegen.cgen = cgen
                 self.readCodegen.currentStructInfo = structInfo
+                self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
+
                 if category == "struct":
                     # unmarshal 'let' parameters first
                     for letp in letParams:
@@ -797,6 +840,8 @@ class VulkanMarshaling(VulkanWrapperGenerator):
                 self.readCodegen.cgen = cgen
                 self.readCodegen.currentStructInfo = structInfo
                 self.readCodegen.doFiltering = False
+                self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
+
                 if category == "struct":
                     # unmarshal 'let' parameters first
                     for letp in letParams:
@@ -854,12 +899,14 @@ class VulkanMarshaling(VulkanWrapperGenerator):
         accessVar = "structAccess"
         sizeVar = "currExtSize"
         cgen.stmt("VkInstanceCreateInfo* %s = (VkInstanceCreateInfo*)(%s)" % (accessVar, extParam.paramName))
-        cgen.stmt("size_t %s = %s(%s->getFeatureBits(), %s)" % (sizeVar, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME, VULKAN_STREAM_VAR_NAME, extParam.paramName))
+        cgen.stmt("size_t %s = %s(%s->getFeatureBits(), %s, %s)" % (sizeVar,
+                                                                    EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME, VULKAN_STREAM_VAR_NAME, ROOT_TYPE_VAR_NAME, extParam.paramName))
 
         cgen.beginIf("!%s && %s" % (sizeVar, extParam.paramName))
 
         cgen.line("// unknown struct extension; skip and call on its pNext field");
-        cgen.funcCall(None, funcproto.name, ["vkStream", "(void*)%s->pNext" % accessVar])
+        cgen.funcCall(None, funcproto.name, [
+                      "vkStream", ROOT_TYPE_VAR_NAME, "(void*)%s->pNext" % accessVar])
         cgen.stmt("return")
 
         cgen.endIf()
@@ -898,18 +945,19 @@ class VulkanMarshaling(VulkanWrapperGenerator):
             retType,
             extParam,
             forEach,
-            defaultEmit=fatalDefault)
+            defaultEmit=fatalDefault,
+            rootTypeVar=ROOT_TYPE_PARAM)
 
     def onEnd(self,):
         VulkanWrapperGenerator.onEnd(self)
 
         def forEachExtensionMarshal(ext, castedAccess, cgen):
             cgen.funcCall(None, API_PREFIX_MARSHAL + ext.name,
-                          [VULKAN_STREAM_VAR_NAME, castedAccess])
+                          [VULKAN_STREAM_VAR_NAME, ROOT_TYPE_VAR_NAME, castedAccess])
 
         def forEachExtensionUnmarshal(ext, castedAccess, cgen):
             cgen.funcCall(None, API_PREFIX_UNMARSHAL + ext.name,
-                          [VULKAN_STREAM_VAR_NAME, castedAccess])
+                          [VULKAN_STREAM_VAR_NAME, ROOT_TYPE_VAR_NAME, castedAccess])
 
         self.module.appendImpl(
             self.cgenImpl.makeFuncImpl(
diff --git a/registry/vulkan/xml/cereal/marshalingdefs.py b/registry/vulkan/xml/cereal/marshalingdefs.py
index 11bb412b..a5aefebd 100644
--- a/registry/vulkan/xml/cereal/marshalingdefs.py
+++ b/registry/vulkan/xml/cereal/marshalingdefs.py
@@ -368,7 +368,7 @@ typedef struct VkAccelerationStructureInstanceKHRWithoutBitFields {
 """,
         "marshaling": """
 const VkAccelerationStructureInstanceKHRWithoutBitFields* {newInputVarName} = (const VkAccelerationStructureInstanceKHRWithoutBitFields*)({inputVarName});
-marshal_VkTransformMatrixKHR({streamVarName}, (VkTransformMatrixKHR*)(&{newInputVarName}->transform));
+marshal_VkTransformMatrixKHR({streamVarName}, {rootTypeVarName}, (VkTransformMatrixKHR*)(&{newInputVarName}->transform));
 for (uint32_t i = 0; i < 2; i++) {{
     {streamVarName}->write((uint32_t*)&({newInputVarName}->dwords[i]), sizeof(uint32_t));
 }}
@@ -376,7 +376,7 @@ for (uint32_t i = 0; i < 2; i++) {{
 """,
         "unmarshaling": """
 VkAccelerationStructureInstanceKHRWithoutBitFields* {newInputVarName} = (VkAccelerationStructureInstanceKHRWithoutBitFields*)({inputVarName});
-unmarshal_VkTransformMatrixKHR({streamVarName}, (VkTransformMatrixKHR*)(&{newInputVarName}->transform));
+unmarshal_VkTransformMatrixKHR({streamVarName}, {rootTypeVarName}, (VkTransformMatrixKHR*)(&{newInputVarName}->transform));
 for (uint32_t i = 0; i < 2; i++) {{
     {streamVarName}->read((uint32_t*)&({newInputVarName}->dwords[i]), sizeof(uint32_t));
 }}
@@ -385,7 +385,7 @@ for (uint32_t i = 0; i < 2; i++) {{
         "reservedmarshaling": """
 (void)vkStream;
 const VkAccelerationStructureInstanceKHRWithoutBitFields* {newInputVarName} = (const VkAccelerationStructureInstanceKHRWithoutBitFields*)({inputVarName});
-reservedmarshal_VkTransformMatrixKHR({streamVarName}, (VkTransformMatrixKHR*)(&{newInputVarName}->transform), ptr);
+reservedmarshal_VkTransformMatrixKHR({streamVarName}, {rootTypeVarName}, (VkTransformMatrixKHR*)(&{newInputVarName}->transform), ptr);
 for (uint32_t i = 0; i < 2; i++) {{
     memcpy(*ptr, (uint32_t*)&({newInputVarName}->dwords[i]), sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
@@ -395,7 +395,7 @@ memcpy(*ptr, (uint64_t*)&{newInputVarName}->accelerationStructureReference, size
 """,
         "reservedunmarshaling": """
 VkAccelerationStructureInstanceKHRWithoutBitFields* {newInputVarName} = (VkAccelerationStructureInstanceKHRWithoutBitFields*)({inputVarName});
-reservedunmarshal_VkTransformMatrixKHR(vkStream, (VkTransformMatrixKHR*)(&{newInputVarName}->transform), ptr);
+reservedunmarshal_VkTransformMatrixKHR({streamVarName}, {rootTypeVarName}, (VkTransformMatrixKHR*)(&{newInputVarName}->transform), ptr);
 for (uint32_t i = 0; i < 2; i++) {{
     memcpy((uint32_t*)&({newInputVarName}->dwords[i]), *ptr, sizeof(uint32_t));
     *ptr += sizeof(uint32_t);
diff --git a/registry/vulkan/xml/cereal/reservedmarshaling.py b/registry/vulkan/xml/cereal/reservedmarshaling.py
index 8d4146e7..a98aa73b 100644
--- a/registry/vulkan/xml/cereal/reservedmarshaling.py
+++ b/registry/vulkan/xml/cereal/reservedmarshaling.py
@@ -20,12 +20,14 @@ from .common.vulkantypes import \
 
 from .wrapperdefs import VulkanWrapperGenerator
 from .wrapperdefs import VULKAN_STREAM_VAR_NAME
+from .wrapperdefs import ROOT_TYPE_VAR_NAME, ROOT_TYPE_PARAM
 from .wrapperdefs import STREAM_RET_TYPE
 from .wrapperdefs import MARSHAL_INPUT_VAR_NAME
 from .wrapperdefs import UNMARSHAL_INPUT_VAR_NAME
 from .wrapperdefs import PARAMETERS_MARSHALING
 from .wrapperdefs import PARAMETERS_MARSHALING_GUEST
-from .wrapperdefs import STRUCT_EXTENSION_PARAM, STRUCT_EXTENSION_PARAM_FOR_WRITE, EXTENSION_SIZE_API_NAME, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME
+from .wrapperdefs import STYPE_OVERRIDE
+from .wrapperdefs import STRUCT_EXTENSION_PARAM, STRUCT_EXTENSION_PARAM_FOR_WRITE, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME
 from .wrapperdefs import API_PREFIX_RESERVEDMARSHAL
 from .wrapperdefs import API_PREFIX_RESERVEDUNMARSHAL
 
@@ -34,6 +36,7 @@ class VulkanReservedMarshalingCodegen(VulkanTypeIterator):
     def __init__(self,
                  cgen,
                  streamVarName,
+                 rootTypeVarName,
                  inputVarName,
                  ptrVarName,
                  marshalPrefix,
@@ -54,6 +57,7 @@ class VulkanReservedMarshalingCodegen(VulkanTypeIterator):
         self.checked = False
 
         self.streamVarName = streamVarName
+        self.rootTypeVarName = rootTypeVarName
         self.inputVarName = inputVarName
         self.ptrVar = ptrVarName
         self.marshalPrefix = marshalPrefix
@@ -506,7 +510,7 @@ class VulkanReservedMarshalingCodegen(VulkanTypeIterator):
         accessWithCast = "%s(%s)" % (self.makeCastExpr(
             self.getTypeForStreaming(vulkanType)), access)
 
-        callParams = [self.streamVarName, accessWithCast, self.ptrVar]
+        callParams = [self.streamVarName, self.rootTypeVarName, accessWithCast, self.ptrVar]
 
         for (bindName, localName) in vulkanType.binds.items():
             callParams.append(self.getEnvAccessExpr(localName))
@@ -578,7 +582,27 @@ class VulkanReservedMarshalingCodegen(VulkanTypeIterator):
         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
+    # sType values to the |forUnmarshaling| struct. Instead it should overwrite
+    # the sType value.
+    def overwriteSType(self, vulkanType):
+        if self.direction == "read":
+            sTypeParam = copy(vulkanType)
+            sTypeParam.paramName = "sType"
+            sTypeAccess = self.exprAccessor(sTypeParam)
+
+            typeName = vulkanType.parent.typeName
+            if typeName in STYPE_OVERRIDE:
+                self.cgen.stmt("%s = %s" %
+                               (sTypeAccess, STYPE_OVERRIDE[typeName]))
+
     def onStructExtension(self, vulkanType):
+        self.overwriteSType(vulkanType)
+
+        sTypeParam = copy(vulkanType)
+        sTypeParam.paramName = "sType"
+
         access = self.exprAccessor(vulkanType)
         sizeVar = "%s_size" % vulkanType.paramName
 
@@ -587,6 +611,11 @@ class VulkanReservedMarshalingCodegen(VulkanTypeIterator):
         else:
             castedAccessExpr = access
 
+        sTypeAccess = self.exprAccessor(sTypeParam)
+        self.cgen.beginIf("%s == VK_STRUCTURE_TYPE_MAX_ENUM" % self.rootTypeVarName)
+        self.cgen.stmt("%s = %s" % (self.rootTypeVarName, sTypeAccess))
+        self.cgen.endIf()
+
         if self.direction == "read" and self.dynAlloc:
             self.cgen.stmt("uint32_t %s" % sizeVar)
 
@@ -601,17 +630,17 @@ class VulkanReservedMarshalingCodegen(VulkanTypeIterator):
             self.genStreamCall(vulkanType, access, "sizeof(VkStructureType)")
             self.cgen.stmt("VkStructureType extType = *(VkStructureType*)(%s)" % access)
             self.cgen.stmt( \
-                    "%s->alloc((void**)&%s, %s(%s->getFeatureBits(), %s))" %
-                    (self.streamVarName, access, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME, self.streamVarName, access))
+                    "%s->alloc((void**)&%s, %s(%s->getFeatureBits(), %s, %s))" %
+                    (self.streamVarName, access, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME, self.streamVarName, self.rootTypeVarName, access))
             self.cgen.stmt("*(VkStructureType*)%s = extType" % access)
 
             self.cgen.funcCall(None, self.marshalPrefix + "extension_struct",
-                [self.streamVarName, castedAccessExpr, self.ptrVar])
+                [self.streamVarName, self.rootTypeVarName, castedAccessExpr, self.ptrVar])
             self.cgen.endIf()
         else:
 
             self.cgen.funcCall(None, self.marshalPrefix + "extension_struct",
-                [self.streamVarName, castedAccessExpr, self.ptrVar])
+                [self.streamVarName, self.rootTypeVarName, castedAccessExpr, self.ptrVar])
 
     def onPointer(self, vulkanType):
         access = self.exprAccessor(vulkanType)
@@ -712,6 +741,7 @@ class VulkanReservedMarshaling(VulkanWrapperGenerator):
             VulkanReservedMarshalingCodegen(
                 None,
                 VULKAN_STREAM_VAR_NAME,
+                ROOT_TYPE_VAR_NAME,
                 MARSHAL_INPUT_VAR_NAME,
                 self.ptrVarName,
                 API_PREFIX_RESERVEDMARSHAL,
@@ -722,6 +752,7 @@ class VulkanReservedMarshaling(VulkanWrapperGenerator):
             VulkanReservedMarshalingCodegen(
                 None,
                 VULKAN_STREAM_VAR_NAME,
+                ROOT_TYPE_VAR_NAME,
                 UNMARSHAL_INPUT_VAR_NAME,
                 self.ptrVarName,
                 API_PREFIX_RESERVEDUNMARSHAL,
@@ -805,6 +836,7 @@ class VulkanReservedMarshaling(VulkanWrapperGenerator):
                     CUSTOM_MARSHAL_TYPES[name]["common"] + \
                     CUSTOM_MARSHAL_TYPES[name]["reservedmarshaling"].format(
                         streamVarName=self.writeCodegen.streamVarName, 
+                        rootTypeVarName=self.writeCodegen.rootTypeVarName,
                         inputVarName=self.writeCodegen.inputVarName,
                         newInputVarName=self.writeCodegen.inputVarName + "_new")
                 for line in marshalingCode.split('\n'):
@@ -814,6 +846,7 @@ class VulkanReservedMarshaling(VulkanWrapperGenerator):
                 self.writeCodegen.cgen = cgen
                 self.writeCodegen.currentStructInfo = structInfo
                 self.writeCodegen.cgen.stmt("(void)%s" % VULKAN_STREAM_VAR_NAME)
+                self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
 
                 if category == "struct":
                     # marshal 'let' parameters first
@@ -830,6 +863,7 @@ class VulkanReservedMarshaling(VulkanWrapperGenerator):
                 self.writeCodegen.currentStructInfo = structInfo
                 self.writeCodegen.doFiltering = False
                 self.writeCodegen.cgen.stmt("(void)%s" % VULKAN_STREAM_VAR_NAME)
+                self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
 
                 if category == "struct":
                     # marshal 'let' parameters first
@@ -879,6 +913,7 @@ class VulkanReservedMarshaling(VulkanWrapperGenerator):
                     CUSTOM_MARSHAL_TYPES[name]["common"] + \
                     CUSTOM_MARSHAL_TYPES[name]["reservedunmarshaling"].format(
                         streamVarName=self.readCodegen.streamVarName, 
+                        rootTypeVarName=self.readCodegen.rootTypeVarName,
                         inputVarName=self.readCodegen.inputVarName,
                         newInputVarName=self.readCodegen.inputVarName + "_new")
                 for line in unmarshalingCode.split('\n'):
@@ -938,12 +973,12 @@ class VulkanReservedMarshaling(VulkanWrapperGenerator):
         accessVar = "structAccess"
         sizeVar = "currExtSize"
         cgen.stmt("VkInstanceCreateInfo* %s = (VkInstanceCreateInfo*)(%s)" % (accessVar, extParam.paramName))
-        cgen.stmt("uint32_t %s = %s(%s->getFeatureBits(), %s)" % (sizeVar, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME, VULKAN_STREAM_VAR_NAME, extParam.paramName))
+        cgen.stmt("uint32_t %s = %s(%s->getFeatureBits(), %s, %s)" % (sizeVar, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME, VULKAN_STREAM_VAR_NAME, ROOT_TYPE_VAR_NAME, extParam.paramName))
 
         cgen.beginIf("!%s && %s" % (sizeVar, extParam.paramName))
 
         cgen.line("// unknown struct extension; skip and call on its pNext field");
-        cgen.funcCall(None, funcproto.name, ["vkStream", "(void*)%s->pNext" % accessVar, self.ptrVarName])
+        cgen.funcCall(None, funcproto.name, ["vkStream", ROOT_TYPE_VAR_NAME, "(void*)%s->pNext" % accessVar, self.ptrVarName])
         cgen.stmt("return")
 
         cgen.endIf()
@@ -984,18 +1019,19 @@ class VulkanReservedMarshaling(VulkanWrapperGenerator):
             retType,
             extParam,
             forEach,
-            defaultEmit=fatalDefault)
+            defaultEmit=fatalDefault,
+            rootTypeVar=ROOT_TYPE_PARAM)
 
     def onEnd(self,):
         VulkanWrapperGenerator.onEnd(self)
 
         def forEachExtensionMarshal(ext, castedAccess, cgen):
             cgen.funcCall(None, API_PREFIX_RESERVEDMARSHAL + ext.name,
-                          [VULKAN_STREAM_VAR_NAME, castedAccess, self.ptrVarName])
+                          [VULKAN_STREAM_VAR_NAME, ROOT_TYPE_VAR_NAME, castedAccess, self.ptrVarName])
 
         def forEachExtensionUnmarshal(ext, castedAccess, cgen):
             cgen.funcCall(None, API_PREFIX_RESERVEDUNMARSHAL + ext.name,
-                          [VULKAN_STREAM_VAR_NAME, castedAccess, self.ptrVarName])
+                          [VULKAN_STREAM_VAR_NAME, ROOT_TYPE_VAR_NAME, castedAccess, self.ptrVarName])
 
         if self.variant != "host":
             self.module.appendImpl(
diff --git a/registry/vulkan/xml/cereal/subdecode.py b/registry/vulkan/xml/cereal/subdecode.py
index 9db2d115..3efb24a3 100644
--- a/registry/vulkan/xml/cereal/subdecode.py
+++ b/registry/vulkan/xml/cereal/subdecode.py
@@ -1,13 +1,13 @@
 from .common.codegen import CodeGen, VulkanWrapperGenerator, VulkanAPIWrapper
 from .common.vulkantypes import \
-        VulkanAPI, makeVulkanTypeSimple, iterateVulkanType, DISPATCHABLE_HANDLE_TYPES, NON_DISPATCHABLE_HANDLE_TYPES
+    VulkanAPI, makeVulkanTypeSimple, iterateVulkanType, DISPATCHABLE_HANDLE_TYPES, NON_DISPATCHABLE_HANDLE_TYPES
 
-from .marshaling import VulkanMarshalingCodegen
 from .reservedmarshaling import VulkanReservedMarshalingCodegen
 from .transform import TransformCodegen, genTransformsForVulkanType
 
 from .wrapperdefs import API_PREFIX_MARSHAL
 from .wrapperdefs import API_PREFIX_UNMARSHAL, API_PREFIX_RESERVEDUNMARSHAL
+from .wrapperdefs import ROOT_TYPE_DEFAULT_VALUE
 from .wrapperdefs import VULKAN_STREAM_TYPE
 
 from copy import copy
@@ -15,19 +15,20 @@ from copy import copy
 decoder_decl_preamble = """
 """
 
-decoder_impl_preamble ="""
+decoder_impl_preamble = """
 """
 
 READ_STREAM = "readStream"
 WRITE_STREAM = "vkStream"
 
 # Driver workarounds for APIs that don't work well multithreaded
-driver_workarounds_global_lock_apis = [ \
+driver_workarounds_global_lock_apis = [
     "vkCreatePipelineLayout",
     "vkDestroyPipelineLayout",
 ]
 
-MAX_STACK_ITEMS="16"
+MAX_STACK_ITEMS = "16"
+
 
 def emit_param_decl_for_reading(param, cgen):
     if param.staticArrExpr:
@@ -44,13 +45,16 @@ def emit_param_decl_for_reading(param, cgen):
         arrSize = "1" if "1" == lenAccess else "MAX_STACK_ITEMS"
 
         typeHere = "uint8_t*" if "void" == param.typeName else param.typeName
-        cgen.stmt("%s%s stack_%s[%s]" % (typeHere, "*" * (param.pointerIndirectionLevels - 1), param.paramName, arrSize))
+        cgen.stmt("%s%s stack_%s[%s]" % (
+            typeHere, "*" * (param.pointerIndirectionLevels - 1), param.paramName, arrSize))
+
 
-def emit_unmarshal(typeInfo, param, cgen, output = False, destroy = False, noUnbox = False):
+def emit_unmarshal(typeInfo, param, cgen, output=False, destroy=False, noUnbox=False):
     if destroy:
         iterateVulkanType(typeInfo, param, VulkanReservedMarshalingCodegen(
             cgen,
             READ_STREAM,
+            ROOT_TYPE_DEFAULT_VALUE,
             param.paramName,
             "readStreamPtrPtr",
             API_PREFIX_RESERVEDUNMARSHAL,
@@ -60,14 +64,18 @@ def emit_unmarshal(typeInfo, param, cgen, output = False, destroy = False, noUnb
         lenAccess = cgen.generalLengthAccess(param)
         lenAccessGuard = cgen.generalLengthAccessGuard(param)
         if None == lenAccess or "1" == lenAccess:
-            cgen.stmt("boxed_%s_preserve = %s" % (param.paramName, param.paramName))
-            cgen.stmt("%s = unbox_%s(%s)" % (param.paramName, param.typeName, param.paramName))
+            cgen.stmt("boxed_%s_preserve = %s" %
+                      (param.paramName, param.paramName))
+            cgen.stmt("%s = unbox_%s(%s)" %
+                      (param.paramName, param.typeName, param.paramName))
         else:
             if lenAccessGuard is not None:
                 self.cgen.beginIf(lenAccessGuard)
             cgen.beginFor("uint32_t i = 0", "i < %s" % lenAccess, "++i")
-            cgen.stmt("boxed_%s_preserve[i] = %s[i]" % (param.paramName, param.paramName))
-            cgen.stmt("((%s*)(%s))[i] = unbox_%s(%s[i])" % (param.typeName, param.paramName, param.typeName, param.paramName))
+            cgen.stmt("boxed_%s_preserve[i] = %s[i]" %
+                      (param.paramName, param.paramName))
+            cgen.stmt("((%s*)(%s))[i] = unbox_%s(%s[i])" % (param.typeName,
+                                                            param.paramName, param.typeName, param.paramName))
             cgen.endFor()
             if lenAccessGuard is not None:
                 self.cgen.endIf()
@@ -83,6 +91,7 @@ def emit_unmarshal(typeInfo, param, cgen, output = False, destroy = False, noUnb
         iterateVulkanType(typeInfo, param, VulkanReservedMarshalingCodegen(
             cgen,
             READ_STREAM,
+            ROOT_TYPE_DEFAULT_VALUE,
             param.paramName,
             "readStreamPtrPtr",
             API_PREFIX_RESERVEDUNMARSHAL,
@@ -92,12 +101,15 @@ def emit_unmarshal(typeInfo, param, cgen, output = False, destroy = False, noUnb
             stackVar="stack_%s" % param.paramName,
             stackArrSize=arrSize))
 
+
 def emit_dispatch_unmarshal(typeInfo, param, cgen, globalWrapped):
     if globalWrapped:
-        cgen.stmt("// Begin global wrapped dispatchable handle unboxing for %s" % param.paramName)
+        cgen.stmt(
+            "// Begin global wrapped dispatchable handle unboxing for %s" % param.paramName)
         iterateVulkanType(typeInfo, param, VulkanReservedMarshalingCodegen(
             cgen,
             READ_STREAM,
+            ROOT_TYPE_DEFAULT_VALUE,
             param.paramName,
             "readStreamPtrPtr",
             API_PREFIX_RESERVEDUNMARSHAL,
@@ -105,11 +117,13 @@ def emit_dispatch_unmarshal(typeInfo, param, cgen, globalWrapped):
             direction="read",
             dynAlloc=True))
     else:
-        cgen.stmt("// Begin non wrapped dispatchable handle unboxing for %s" % param.paramName)
+        cgen.stmt(
+            "// Begin non wrapped dispatchable handle unboxing for %s" % param.paramName)
         # cgen.stmt("%s->unsetHandleMapping()" % READ_STREAM)
         iterateVulkanType(typeInfo, param, VulkanReservedMarshalingCodegen(
             cgen,
             READ_STREAM,
+            ROOT_TYPE_DEFAULT_VALUE,
             param.paramName,
             "readStreamPtrPtr",
             API_PREFIX_RESERVEDUNMARSHAL,
@@ -120,16 +134,20 @@ def emit_dispatch_unmarshal(typeInfo, param, cgen, globalWrapped):
                   (param.paramName, param.typeName, param.paramName))
         cgen.stmt("auto vk = dispatch_%s(%s)" %
                   (param.typeName, param.paramName))
-        cgen.stmt("// End manual dispatchable handle unboxing for %s" % param.paramName)
+        cgen.stmt("// End manual dispatchable handle unboxing for %s" %
+                  param.paramName)
+
 
 def emit_transform(typeInfo, param, cgen, variant="tohost"):
     res = \
-        iterateVulkanType(typeInfo, param, TransformCodegen( \
-        cgen, param.paramName, "globalstate", "transform_%s_" % variant, variant))
+        iterateVulkanType(typeInfo, param, TransformCodegen(
+            cgen, param.paramName, "globalstate", "transform_%s_" % variant, variant))
     if not res:
         cgen.stmt("(void)%s" % param.paramName)
 
 # Everything here elides the initial arg
+
+
 class DecodingParameters(object):
     def __init__(self, api):
         self.params = []
@@ -169,6 +187,7 @@ class DecodingParameters(object):
 
             i += 1
 
+
 def emit_call_log(api, cgen):
     decodingParams = DecodingParameters(api)
     paramsToRead = decodingParams.toRead
@@ -184,6 +203,7 @@ def emit_call_log(api, cgen):
     # cgen.stmt("fprintf(stderr, \"substream %%p: call %s %s\\n\", readStream, %s)" % (api.name, paramLogFormat, ", ".join(paramLogArgs)))
     # cgen.endIf()
 
+
 def emit_decode_parameters(typeInfo, api, cgen, globalWrapped=False):
 
     decodingParams = DecodingParameters(api)
@@ -195,7 +215,7 @@ def emit_decode_parameters(typeInfo, api, cgen, globalWrapped=False):
 
     i = 0
     for p in paramsToRead:
-        lenAccess =  cgen.generalLengthAccess(p)
+        lenAccess = cgen.generalLengthAccess(p)
 
         if p.dispatchHandle:
             emit_dispatch_unmarshal(typeInfo, p, cgen, globalWrapped)
@@ -205,24 +225,30 @@ def emit_decode_parameters(typeInfo, api, cgen, globalWrapped=False):
 
             if p.nonDispatchableHandleDestroy or p.dispatchableHandleDestroy:
                 destroy = True
-                cgen.stmt("// Begin manual non dispatchable handle destroy unboxing for %s" % p.paramName)
+                cgen.stmt(
+                    "// Begin manual non dispatchable handle destroy unboxing for %s" % p.paramName)
                 if None == lenAccess or "1" == lenAccess:
-                    cgen.stmt("%s boxed_%s_preserve" % (p.typeName, p.paramName))
+                    cgen.stmt("%s boxed_%s_preserve" %
+                              (p.typeName, p.paramName))
                 else:
-                    cgen.stmt("%s* boxed_%s_preserve; %s->alloc((void**)&boxed_%s_preserve, %s * sizeof(%s))" % (p.typeName, p.paramName, READ_STREAM, p.paramName, lenAccess, p.typeName))
+                    cgen.stmt("%s* boxed_%s_preserve; %s->alloc((void**)&boxed_%s_preserve, %s * sizeof(%s))" %
+                              (p.typeName, p.paramName, READ_STREAM, p.paramName, lenAccess, p.typeName))
 
             if p.possiblyOutput():
-                cgen.stmt("// Begin manual dispatchable handle unboxing for %s" % p.paramName)
+                cgen.stmt(
+                    "// Begin manual dispatchable handle unboxing for %s" % p.paramName)
                 cgen.stmt("%s->unsetHandleMapping()" % READ_STREAM)
 
-            emit_unmarshal(typeInfo, p, cgen, output = p.possiblyOutput(), destroy = destroy, noUnbox = noUnbox)
+            emit_unmarshal(typeInfo, p, cgen, output=p.possiblyOutput(
+            ), destroy=destroy, noUnbox=noUnbox)
         i += 1
 
     for p in paramsToRead:
-        emit_transform(typeInfo, p, cgen, variant="tohost");
+        emit_transform(typeInfo, p, cgen, variant="tohost")
 
     emit_call_log(api, cgen)
 
+
 def emit_dispatch_call(api, cgen):
 
     decodingParams = DecodingParameters(api)
@@ -243,35 +269,41 @@ def emit_dispatch_call(api, cgen):
     if api.name in driver_workarounds_global_lock_apis:
         cgen.stmt("unlock()")
 
+
 def emit_global_state_wrapped_call(api, cgen):
-    customParams = ["pool", "(VkCommandBuffer)(boxed_dispatchHandle)"] + list(map(lambda p: p.paramName, api.parameters[1:]))
-    cgen.vkApiCall(api, customPrefix="this->on_", \
-        customParameters=customParams)
+    customParams = ["pool", "(VkCommandBuffer)(boxed_dispatchHandle)"] + \
+        list(map(lambda p: p.paramName, api.parameters[1:]))
+    cgen.vkApiCall(api, customPrefix="this->on_",
+                   customParameters=customParams)
+
 
 def emit_default_decoding(typeInfo, api, cgen):
     emit_decode_parameters(typeInfo, api, cgen)
     emit_dispatch_call(api, cgen)
 
+
 def emit_global_state_wrapped_decoding(typeInfo, api, cgen):
     emit_decode_parameters(typeInfo, api, cgen, globalWrapped=True)
     emit_global_state_wrapped_call(api, cgen)
 
+
 custom_decodes = {
-    "vkCmdCopyBufferToImage" : emit_global_state_wrapped_decoding,
-    "vkCmdCopyImage" : emit_global_state_wrapped_decoding,
-    "vkCmdCopyImageToBuffer" : emit_global_state_wrapped_decoding,
-    "vkCmdExecuteCommands" : emit_global_state_wrapped_decoding,
-    "vkBeginCommandBuffer" : emit_global_state_wrapped_decoding,
-    "vkResetCommandBuffer" : emit_global_state_wrapped_decoding,
-    "vkCmdPipelineBarrier" : emit_global_state_wrapped_decoding,
-    "vkCmdBindPipeline" : emit_global_state_wrapped_decoding,
-    "vkCmdBindDescriptorSets" : emit_global_state_wrapped_decoding,
-    "vkBeginCommandBufferAsyncGOOGLE" : emit_global_state_wrapped_decoding,
-    "vkEndCommandBufferAsyncGOOGLE" : emit_global_state_wrapped_decoding,
-    "vkResetCommandBufferAsyncGOOGLE" : emit_global_state_wrapped_decoding,
-    "vkCommandBufferHostSyncGOOGLE" : emit_global_state_wrapped_decoding,
+    "vkCmdCopyBufferToImage": emit_global_state_wrapped_decoding,
+    "vkCmdCopyImage": emit_global_state_wrapped_decoding,
+    "vkCmdCopyImageToBuffer": emit_global_state_wrapped_decoding,
+    "vkCmdExecuteCommands": emit_global_state_wrapped_decoding,
+    "vkBeginCommandBuffer": emit_global_state_wrapped_decoding,
+    "vkResetCommandBuffer": emit_global_state_wrapped_decoding,
+    "vkCmdPipelineBarrier": emit_global_state_wrapped_decoding,
+    "vkCmdBindPipeline": emit_global_state_wrapped_decoding,
+    "vkCmdBindDescriptorSets": emit_global_state_wrapped_decoding,
+    "vkBeginCommandBufferAsyncGOOGLE": emit_global_state_wrapped_decoding,
+    "vkEndCommandBufferAsyncGOOGLE": emit_global_state_wrapped_decoding,
+    "vkResetCommandBufferAsyncGOOGLE": emit_global_state_wrapped_decoding,
+    "vkCommandBufferHostSyncGOOGLE": emit_global_state_wrapped_decoding,
 }
 
+
 class VulkanSubDecoder(VulkanWrapperGenerator):
     def __init__(self, module, typeInfo):
         VulkanWrapperGenerator.__init__(self, module, typeInfo)
@@ -279,31 +311,36 @@ class VulkanSubDecoder(VulkanWrapperGenerator):
         self.cgen = CodeGen()
 
     def onBegin(self,):
-        self.module.appendImpl("#define MAX_STACK_ITEMS %s\n" % MAX_STACK_ITEMS)
+        self.module.appendImpl(
+            "#define MAX_STACK_ITEMS %s\n" % MAX_STACK_ITEMS)
 
         self.module.appendImpl(
             "size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* boxed_dispatchHandle, void* dispatchHandle, VkDeviceSize dataSize, const void* pData)\n")
 
-        self.cgen.beginBlock() # function body
+        self.cgen.beginBlock()  # function body
 
         self.cgen.stmt("uint32_t count = 0")
         self.cgen.stmt("unsigned char *buf = (unsigned char *)pData")
         self.cgen.stmt("android::base::BumpPool* pool = readStream->pool()")
         self.cgen.stmt("unsigned char *ptr = (unsigned char *)pData")
-        self.cgen.stmt("const unsigned char* const end = (const unsigned char*)buf + dataSize")
-        self.cgen.stmt("VkDecoderGlobalState* globalstate = VkDecoderGlobalState::get()")
+        self.cgen.stmt(
+            "const unsigned char* const end = (const unsigned char*)buf + dataSize")
+        self.cgen.stmt(
+            "VkDecoderGlobalState* globalstate = VkDecoderGlobalState::get()")
 
         self.cgen.line("while (end - ptr >= 8)")
-        self.cgen.beginBlock() # while loop
+        self.cgen.beginBlock()  # while loop
 
         self.cgen.stmt("uint32_t opcode = *(uint32_t *)ptr")
         self.cgen.stmt("int32_t packetLen = *(int32_t *)(ptr + 4)")
-        self.cgen.stmt("if (end - ptr < packetLen) return ptr - (unsigned char*)buf")
+        self.cgen.stmt(
+            "if (end - ptr < packetLen) return ptr - (unsigned char*)buf")
 
         self.cgen.stmt("%s->setBuf((uint8_t*)(ptr + 8))" % READ_STREAM)
-        self.cgen.stmt("uint8_t* readStreamPtr = %s->getBuf(); uint8_t** readStreamPtrPtr = &readStreamPtr" % READ_STREAM)
+        self.cgen.stmt(
+            "uint8_t* readStreamPtr = %s->getBuf(); uint8_t** readStreamPtrPtr = &readStreamPtr" % READ_STREAM)
         self.cgen.line("switch (opcode)")
-        self.cgen.beginBlock() # switch stmt
+        self.cgen.beginBlock()  # switch stmt
 
         self.module.appendImpl(self.cgen.swapCode())
 
@@ -332,18 +369,19 @@ class VulkanSubDecoder(VulkanWrapperGenerator):
     def onEnd(self,):
         self.cgen.line("default:")
         self.cgen.beginBlock()
-        self.cgen.stmt("fprintf(stderr, \"Fatal, unrecognized opcode %u\\n\", opcode)")
+        self.cgen.stmt(
+            "fprintf(stderr, \"Fatal, unrecognized opcode %u\\n\", opcode)")
         self.cgen.stmt("abort()")
         self.cgen.stmt("return ptr - (unsigned char *)buf")
         self.cgen.endBlock()
 
-        self.cgen.endBlock() # switch stmt
+        self.cgen.endBlock()  # switch stmt
 
         self.cgen.stmt("++count; if (count % 1000 == 0) { pool->freeAll(); }")
         self.cgen.stmt("ptr += packetLen")
-        self.cgen.endBlock() # while loop
+        self.cgen.endBlock()  # while loop
 
         self.cgen.stmt("pool->freeAll()")
         self.cgen.stmt("return ptr - (unsigned char*)buf;")
-        self.cgen.endBlock() # function body
+        self.cgen.endBlock()  # function body
         self.module.appendImpl(self.cgen.swapCode())
diff --git a/registry/vulkan/xml/cereal/wrapperdefs.py b/registry/vulkan/xml/cereal/wrapperdefs.py
index ece17652..1a20f93d 100644
--- a/registry/vulkan/xml/cereal/wrapperdefs.py
+++ b/registry/vulkan/xml/cereal/wrapperdefs.py
@@ -39,11 +39,20 @@ VALIDATE_RESULT_TYPE = "VkResult"
 VALIDATE_VAR_NAME = "validateResult"
 VALIDATE_GOOD_RESULT = "VK_SUCCESS"
 
+ROOT_TYPE_VAR_NAME = "rootType"
+ROOT_TYPE_DEFAULT_VALUE = "VK_STRUCTURE_TYPE_MAX_ENUM"
+ROOT_TYPE_TYPE = "VkStructureType"
+ROOT_TYPE_PARAM = makeVulkanTypeSimple(
+    False, ROOT_TYPE_TYPE, 0, ROOT_TYPE_VAR_NAME)
+
 PARAMETERS_MARSHALING = [
-    makeVulkanTypeSimple(False, VULKAN_STREAM_TYPE, 1, VULKAN_STREAM_VAR_NAME)
+    makeVulkanTypeSimple(False, VULKAN_STREAM_TYPE, 1, VULKAN_STREAM_VAR_NAME),
+    ROOT_TYPE_PARAM,
 ]
 PARAMETERS_MARSHALING_GUEST = [
-    makeVulkanTypeSimple(False, VULKAN_STREAM_TYPE_GUEST, 1, VULKAN_STREAM_VAR_NAME)
+    makeVulkanTypeSimple(False, VULKAN_STREAM_TYPE_GUEST,
+                         1, VULKAN_STREAM_VAR_NAME),
+    ROOT_TYPE_PARAM,
 ]
 PARAMETERS_VALIDATE = [
     makeVulkanTypeSimple(False, VALIDATE_RESULT_TYPE, 1, VALIDATE_VAR_NAME)
@@ -81,3 +90,15 @@ RELAXED_APIS = [
     "vkDeviceWaitIdle",
     "vkQueueFlushCommandsGOOGLE",
 ]
+
+STYPE_OVERRIDE = {
+    "VkPhysicalDeviceFragmentDensityMapFeaturesEXT": "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT",
+    "VkPhysicalDeviceFragmentDensityMapPropertiesEXT": "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT",
+    "VkRenderPassFragmentDensityMapCreateInfoEXT": "VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT",
+    "VkImportColorBufferGOOGLE": "VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE",
+    "VkImportPhysicalAddressGOOGLE": "VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE",
+    "VkImportBufferGOOGLE": "VK_STRUCTURE_TYPE_IMPORT_BUFFER_GOOGLE",
+}
+
+
+
diff --git a/registry/vulkan/xml/vk.xml b/registry/vulkan/xml/vk.xml
index a921f0a1..a7fe8987 100644
--- a/registry/vulkan/xml/vk.xml
+++ b/registry/vulkan/xml/vk.xml
@@ -13330,9 +13330,7 @@ typedef void <name>CAMetalLayer</name>;
                 <type name="CAMetalLayer"/>
             </require>
         </extension>
-        <!-- TODO(liyl): This extension number (219) collides with VK_GOOGLE_color_buffer, which has its extension id hardcoded in goldfish Vulkan ICD. -->
-        <!-- Thus we changed the number to an unused number and disabled it. -->
-        <extension name="VK_EXT_fragment_density_map" number="919" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Matthew Netsch @mnetsch" supported="disabled">
+        <extension name="VK_EXT_fragment_density_map" number="219" type="device" requires="VK_KHR_get_physical_device_properties2" author="EXT" contact="Matthew Netsch @mnetsch" supported="vulkan">
             <require>
                 <enum value="1"                                             name="VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION"/>
                 <enum value="&quot;VK_EXT_fragment_density_map&quot;"       name="VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME"/>
@@ -14693,29 +14691,19 @@ typedef void <name>CAMetalLayer</name>;
                 <enum bitpos="15" extends="VkImageCreateFlagBits"       name="VK_IMAGE_CREATE_RESERVED_15_BIT_NV"/>
             </require>
         </extension>
-        <!-- TODO(liyl): This extension number (219) collides with VK_EXT_fragment_density_map, though we have a few extension -->
-        <!-- IDs / struct type IDs hardcoded in goldfish Vulkan ICD. Thus we kept the number and changed -->
-        <!-- the extension number of VK_EXT_fragment_density_map to 919. -->
-        <extension name="VK_GOOGLE_color_buffer" number="219" author="GOOGLE" contact="Lingfeng Yang @frank" supported="vulkan">
+        <extension name="VK_GOOGLE_gfxstream" number="386" author="GOOGLE" contact="Lingfeng Yang @frank,Roman Kiryanov @rkir,Yilong Li @liyl_google" supported="vulkan">
             <require>
-                <enum value="0"                                             name="VK_GOOGLE_COLOR_BUFFER_SPEC_VERSION"/>
-                <enum value="219"                                           name="VK_GOOGLE_COLOR_BUFFER_NUMBER"/>
-                <enum value="&quot;VK_GOOGLE_color_buffer&quot;"            name="VK_GOOGLE_COLOR_BUFFER_EXTENSION_NAME"/>
+                <enum value="0"                                             name="VK_GOOGLE_GFXSTREAM_SPEC_VERSION"/>
+                <enum value="386"                                           name="VK_GOOGLE_GFXSTREAM_NUMBER"/>
+                <enum value="&quot;VK_GOOGLE_gfxstream&quot;"               name="VK_GOOGLE_GFXSTREAM_EXTENSION_NAME"/>
                 <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_IMPORT_COLOR_BUFFER_GOOGLE"/>
                 <enum offset="1" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_IMPORT_PHYSICAL_ADDRESS_GOOGLE"/>
-                <enum offset="0" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_IMPORT_BUFFER_HANDLE_GOOGLE"/>
+                <enum offset="2" extends="VkStructureType"                  name="VK_STRUCTURE_TYPE_IMPORT_BUFFER_HANDLE_GOOGLE"/>
                 <type name="VkImportColorBufferGOOGLE"/>
                 <type name="VkImportBufferGOOGLE"/>
                 <type name="VkImportPhysicalAddressGOOGLE"/>
                 <command name="vkRegisterImageColorBufferGOOGLE"/>
                 <command name="vkRegisterBufferColorBufferGOOGLE"/>
-            </require>
-        </extension>
-        <extension name="VK_GOOGLE_gfxstream" number="386" author="GOOGLE" contact="Lingfeng Yang @frank,Roman Kiryanov @rkir,Yilong Li @liyl_google" supported="vulkan">
-            <require>
-                <enum value="0"                                             name="VK_GOOGLE_GFXSTREAM_SPEC_VERSION"/>
-                <enum value="386"                                           name="VK_GOOGLE_GFXSTREAM_NUMBER"/>
-                <enum value="&quot;VK_GOOGLE_gfxstream&quot;"               name="VK_GOOGLE_GFXSTREAM_EXTENSION_NAME"/>
                 <command name="vkMapMemoryIntoAddressSpaceGOOGLE"/>
                 <command name="vkUpdateDescriptorSetWithTemplateSizedGOOGLE"/>
                 <command name="vkBeginCommandBufferAsyncGOOGLE"/>