349 lines
13 KiB
Python
349 lines
13 KiB
Python
# 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)))
|