path: root/codegen/vulkan/scripts/cereal/transform.py

# Copyright (c) 2018 The Android Open Source Project
# Copyright (c) 2018 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from .common.codegen import CodeGen
from .common.vulkantypes import \
        VulkanCompoundType, VulkanAPI, makeVulkanTypeSimple, vulkanTypeNeedsTransform, vulkanTypeGetNeededTransformTypes, VulkanTypeIterator, iterateVulkanType, vulkanTypeforEachSubType, TRIVIAL_TRANSFORMED_TYPES, NON_TRIVIAL_TRANSFORMED_TYPES, TRANSFORMED_TYPES

from .wrapperdefs import VulkanWrapperGenerator
from .wrapperdefs import STRUCT_EXTENSION_PARAM, STRUCT_EXTENSION_PARAM_FOR_WRITE

def deviceMemoryTransform(resourceTrackerVarName, structOrApiInfo, getExpr, getLen, cgen, variant="tohost"):
    paramIndices = \
        structOrApiInfo.deviceMemoryInfoParameterIndices

    for _, info in paramIndices.items():
        orderedKeys = [
            "handle",
            "offset",
            "size",
            "typeIndex",
            "typeBits",]
        
        casts = {
            "handle" : "VkDeviceMemory*",
            "offset" : "VkDeviceSize*",
            "size" : "VkDeviceSize*",
            "typeIndex" : "uint32_t*",
            "typeBits" : "uint32_t*",
        }

        accesses = {
            "handle" : "nullptr",
            "offset" : "nullptr",
            "size" : "nullptr",
            "typeIndex" : "nullptr",
            "typeBits" : "nullptr",
        }

        lenAccesses = {
            "handle" : "0",
            "offset" : "0",
            "size" : "0",
            "typeIndex" : "0",
            "typeBits" : "0",
        }

        def doParam(i, vulkanType):
            access = getExpr(vulkanType)
            lenAccess = getLen(vulkanType)

            for k in orderedKeys:
                if i == info.__dict__[k]:
                    accesses[k] = access
                    if lenAccess is not None:
                        lenAccesses[k] = lenAccess
                    else:
                        lenAccesses[k] = "1"

        vulkanTypeforEachSubType(structOrApiInfo, doParam)

        callParams = ", ".join( \
            ["(%s)%s, %s" % (casts[k], accesses[k], lenAccesses[k]) \
                for k in orderedKeys])

        if variant == "tohost":
            cgen.stmt("%s->deviceMemoryTransform_tohost(%s)" % \
                (resourceTrackerVarName, callParams))
        else:
            cgen.stmt("%s->deviceMemoryTransform_fromhost(%s)" % \
                (resourceTrackerVarName, callParams))

def directTransform(resourceTrackerVarName, vulkanType, getExpr, getLen, cgen, variant="tohost"):
    access = getExpr(vulkanType)
    lenAccess = getLen(vulkanType)

    if lenAccess:
        finalLenAccess = lenAccess
    else:
        finalLenAccess = "1"

    cgen.stmt("%s->transformImpl_%s_%s(%s, %s)" % (resourceTrackerVarName,
                                                   vulkanType.typeName, variant, access, finalLenAccess))

def genTransformsForVulkanType(resourceTrackerVarName, structOrApiInfo, getExpr, getLen, cgen, variant="tohost"):
    for transform in vulkanTypeGetNeededTransformTypes(structOrApiInfo):
        if transform == "devicememory":
            deviceMemoryTransform( \
                resourceTrackerVarName,
                structOrApiInfo,
                getExpr, getLen, cgen, variant=variant)

class TransformCodegen(VulkanTypeIterator):
    def __init__(self, cgen, inputVar, resourceTrackerVarName, prefix, variant):
        self.cgen = cgen
        self.inputVar = inputVar
        self.prefix = prefix
        self.resourceTrackerVarName = resourceTrackerVarName

        def makeAccess(varName, asPtr = True):
            return lambda t: self.cgen.generalAccess(t, parentVarName = varName, asPtr = asPtr)

        def makeLengthAccess(varName):
            return lambda t: self.cgen.generalLengthAccess(t, parentVarName = varName)

        def makeLengthAccessGuard(varName):
            return lambda t: self.cgen.generalLengthAccessGuard(t, parentVarName=varName)

        self.exprAccessor = makeAccess(self.inputVar)
        self.exprAccessorValue = makeAccess(self.inputVar, asPtr = False)
        self.lenAccessor = makeLengthAccess(self.inputVar)
        self.lenAccessorGuard = makeLengthAccessGuard(self.inputVar)

        self.checked = False

        self.variant = variant

    def makeCastExpr(self, vulkanType):
        return "(%s)" % (
            self.cgen.makeCTypeDecl(vulkanType, useParamName=False))

    def asNonConstCast(self, access, vulkanType):
        if vulkanType.staticArrExpr:
            casted = "%s(%s)" % (self.makeCastExpr(vulkanType.getForAddressAccess().getForNonConstAccess()), access)
        elif vulkanType.accessibleAsPointer():
            casted = "%s(%s)" % (self.makeCastExpr(vulkanType.getForNonConstAccess()), access)
        else:
            casted = "%s(%s)" % (self.makeCastExpr(vulkanType.getForAddressAccess().getForNonConstAccess()), access)
        return casted

    def onCheck(self, vulkanType):
        pass

    def endCheck(self, vulkanType):
        pass

    def onCompoundType(self, vulkanType):

        access = self.exprAccessor(vulkanType)
        lenAccess = self.lenAccessor(vulkanType)
        lenAccessGuard = self.lenAccessorGuard(vulkanType)

        isPtr = vulkanType.pointerIndirectionLevels > 0

        if lenAccessGuard is not None:
            self.cgen.beginIf(lenAccessGuard)

        if isPtr:
            self.cgen.beginIf(access)

        if lenAccess is not None:

            loopVar = "i"
            access = "%s + %s" % (access, loopVar)
            forInit = "uint32_t %s = 0" % loopVar
            forCond = "%s < (uint32_t)%s" % (loopVar, lenAccess)
            forIncr = "++%s" % loopVar

            self.cgen.beginFor(forInit, forCond, forIncr)

        accessCasted = self.asNonConstCast(access, vulkanType)

        if vulkanType.isTransformed:
            directTransform(self.resourceTrackerVarName, vulkanType, self.exprAccessor, self.lenAccessor, self.cgen, variant=self.variant)

        self.cgen.funcCall(None, self.prefix + vulkanType.typeName,
                           [self.resourceTrackerVarName, accessCasted])

        if lenAccess is not None:
            self.cgen.endFor()

        if isPtr:
            self.cgen.endIf()

        if lenAccessGuard is not None:
            self.cgen.endIf()

    def onString(self, vulkanType):
        pass

    def onStringArray(self, vulkanType):
        pass

    def onStaticArr(self, vulkanType):
        pass

    def onStructExtension(self, vulkanType):
        access = self.exprAccessor(vulkanType)

        castedAccessExpr = "(%s)(%s)" % ("void*", access)
        self.cgen.beginIf(access)
        self.cgen.funcCall(None, self.prefix + "extension_struct",
                           [self.resourceTrackerVarName, castedAccessExpr])
        self.cgen.endIf()

    def onPointer(self, vulkanType):
        pass

    def onValue(self, vulkanType):
        pass


class VulkanTransform(VulkanWrapperGenerator):
    def __init__(self, module, typeInfo, resourceTrackerTypeName="ResourceTracker", resourceTrackerVarName="resourceTracker"):
        VulkanWrapperGenerator.__init__(self, module, typeInfo)

        self.codegen = CodeGen()

        self.transformPrefix = "transform_"

        self.tohostpart = "tohost"
        self.fromhostpart = "fromhost"
        self.variants = [self.tohostpart, self.fromhostpart]

        self.toTransformVar = "toTransform"
        self.resourceTrackerTypeName = resourceTrackerTypeName
        self.resourceTrackerVarName = resourceTrackerVarName
        self.transformParam = \
            makeVulkanTypeSimple(False, self.resourceTrackerTypeName, 1,
                                 self.resourceTrackerVarName)
        self.voidType = makeVulkanTypeSimple(False, "void", 0)

        self.extensionTransformPrototypes = []

        for variant in self.variants:
            self.extensionTransformPrototypes.append( \
                VulkanAPI(self.transformPrefix + variant + "_extension_struct",
                          self.voidType,
                          [self.transformParam, STRUCT_EXTENSION_PARAM_FOR_WRITE]))

        self.knownStructs = {}
        self.needsTransform = set([])

    def onBegin(self,):
        VulkanWrapperGenerator.onBegin(self)
        # Set up a convenience macro fro the transformed structs
        # and forward-declare the resource tracker class
        self.codegen.stmt("class %s" % self.resourceTrackerTypeName)
        self.codegen.line("#define LIST_TRIVIAL_TRANSFORMED_TYPES(f) \\")
        for name in TRIVIAL_TRANSFORMED_TYPES:
            self.codegen.line("f(%s) \\" % name)
        self.codegen.line("")

        self.codegen.line("#define LIST_NON_TRIVIAL_TRANSFORMED_TYPES(f) \\")
        for name in NON_TRIVIAL_TRANSFORMED_TYPES:
            self.codegen.line("f(%s) \\" % name)
        self.codegen.line("")

        self.codegen.line("#define LIST_TRANSFORMED_TYPES(f) \\")
        self.codegen.line("LIST_TRIVIAL_TRANSFORMED_TYPES(f) \\")
        self.codegen.line("LIST_NON_TRIVIAL_TRANSFORMED_TYPES(f) \\")
        self.codegen.line("")

        self.module.appendHeader(self.codegen.swapCode())

        for prototype in self.extensionTransformPrototypes:
            self.module.appendImpl(self.codegen.makeFuncDecl(
                prototype))

    def onGenType(self, typeXml, name, alias):
        VulkanWrapperGenerator.onGenType(self, typeXml, name, alias)

        if name in self.knownStructs:
            return

        category = self.typeInfo.categoryOf(name)

        if category in ["struct", "union"] and alias:
            for variant in self.variants:
                self.module.appendHeader(
                    self.codegen.makeFuncAlias(self.transformPrefix + variant + "_" + name,
                                               self.transformPrefix + variant + "_" + alias))

        if category in ["struct", "union"] and not alias:
            structInfo = self.typeInfo.structs[name]
            self.knownStructs[name] = structInfo

            for variant in self.variants:
                api = VulkanAPI( \
                    self.transformPrefix + variant + "_" + name,
                    self.voidType,
                    [self.transformParam] + \
                    [makeVulkanTypeSimple( \
                        False, name, 1, self.toTransformVar)])

                transformer = TransformCodegen(
                    None,
                    self.toTransformVar,
                    self.resourceTrackerVarName,
                    self.transformPrefix + variant + "_",
                    variant)

                def funcDefGenerator(cgen):
                    transformer.cgen = cgen
                    for p in api.parameters:
                        cgen.stmt("(void)%s" % p.paramName)

                    genTransformsForVulkanType(
                        self.resourceTrackerVarName,
                        structInfo,
                        transformer.exprAccessor,
                        transformer.lenAccessor,
                        cgen,
                        variant=variant)

                    for member in structInfo.members:
                        iterateVulkanType(
                            self.typeInfo, member,
                            transformer)

                self.module.appendHeader(
                    self.codegen.makeFuncDecl(api))
                self.module.appendImpl(
                    self.codegen.makeFuncImpl(api, funcDefGenerator))


    def onGenCmd(self, cmdinfo, name, alias):
        VulkanWrapperGenerator.onGenCmd(self, cmdinfo, name, alias)

    def onEnd(self,):
        VulkanWrapperGenerator.onEnd(self)

        for (variant, prototype) in zip(self.variants, self.extensionTransformPrototypes):
            def forEachExtensionTransform(ext, castedAccess, cgen):
                if ext.isTransformed:
                    directTransform(self.resourceTrackerVarName, ext, lambda _ : castedAccess, lambda _ : "1", cgen, variant);
                cgen.funcCall(None, self.transformPrefix + variant + "_" + ext.name,
                              [self.resourceTrackerVarName, castedAccess])

            self.module.appendImpl(
                self.codegen.makeFuncImpl(
                    prototype,
                    lambda cgen: self.emitForEachStructExtension(
                        cgen,
                        self.voidType,
                        STRUCT_EXTENSION_PARAM_FOR_WRITE,
                        forEachExtensionTransform)))