Debian Codegraph @

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

raw
1 from .common.codegen import CodeGen, VulkanWrapperGenerator
2 from .common.vulkantypes import \
3 VulkanAPI, makeVulkanTypeSimple, iterateVulkanType
4 from .common.vulkantypes import EXCLUDED_APIS
5 from .common.vulkantypes import HANDLE_TYPES
6
7 import copy
8 import re
9
10 RESOURCE_TRACKER_ENTRIES = [
11 "vkEnumerateInstanceExtensionProperties",
12 "vkEnumerateDeviceExtensionProperties",
13 "vkEnumeratePhysicalDevices",
14 "vkAllocateMemory",
15 "vkFreeMemory",
16 "vkCreateImage",
17 "vkDestroyImage",
18 "vkGetImageMemoryRequirements",
19 "vkGetImageMemoryRequirements2",
20 "vkGetImageDrmFormatModifierPropertiesEXT",
21 "vkBindImageMemory",
22 "vkBindImageMemory2",
23 "vkCreateBuffer",
24 "vkDestroyBuffer",
25 "vkGetBufferMemoryRequirements",
26 "vkGetBufferMemoryRequirements2",
27 "vkGetPhysicalDeviceProperties2",
28 "vkGetPhysicalDeviceProperties2KHR",
29 "vkCreateSemaphore",
30 "vkDestroySemaphore",
31 "vkQueueSubmit",
32 "vkQueueSubmit2",
33 "vkQueueWaitIdle",
34 "vkImportSemaphoreFdKHR",
35 "vkGetSemaphoreFdKHR",
36 # Warning: These need to be defined in vk.xml (currently no-op) {
37 "vkGetMemoryFuchsiaHandleKHR",
38 "vkGetMemoryFuchsiaHandlePropertiesKHR",
39 "vkGetSemaphoreFuchsiaHandleKHR",
40 "vkImportSemaphoreFuchsiaHandleKHR",
41 # } end Warning: These need to be defined in vk.xml (currently no-op)
42 "vkGetAndroidHardwareBufferPropertiesANDROID",
43 "vkGetMemoryAndroidHardwareBufferANDROID",
44 "vkGetMemoryFdKHR",
45 "vkGetMemoryFdPropertiesKHR",
46 "vkCreateSamplerYcbcrConversion",
47 "vkDestroySamplerYcbcrConversion",
48 "vkUpdateDescriptorSetWithTemplate",
49 "vkGetPhysicalDeviceFormatProperties2",
50 "vkGetPhysicalDeviceImageFormatProperties2",
51 "vkBeginCommandBuffer",
52 "vkEndCommandBuffer",
53 "vkResetCommandBuffer",
54 "vkCreateImageView",
55 "vkCreateSampler",
56 "vkGetPhysicalDeviceExternalFenceProperties",
57 "vkGetPhysicalDeviceExternalBufferProperties",
58 "vkCreateFence",
59 "vkResetFences",
60 "vkImportFenceFdKHR",
61 "vkGetFenceFdKHR",
62 "vkGetFenceStatus",
63 "vkWaitForFences",
64 "vkCreateDescriptorPool",
65 "vkDestroyDescriptorPool",
66 "vkResetDescriptorPool",
67 "vkAllocateDescriptorSets",
68 "vkFreeDescriptorSets",
69 "vkCreateDescriptorSetLayout",
70 "vkCmdExecuteCommands",
71 "vkCmdBindDescriptorSets",
72 "vkDestroyDescriptorSetLayout",
73 "vkAllocateCommandBuffers",
74 "vkQueueSignalReleaseImageANDROID",
75 "vkCmdPipelineBarrier",
76 "vkCreateGraphicsPipelines",
77 "vkCmdClearColorImage",
78 # Fuchsia
79 "vkGetMemoryZirconHandleFUCHSIA",
80 "vkGetMemoryZirconHandlePropertiesFUCHSIA",
81 "vkGetSemaphoreZirconHandleFUCHSIA",
82 "vkImportSemaphoreZirconHandleFUCHSIA",
83 "vkCreateBufferCollectionFUCHSIA",
84 "vkDestroyBufferCollectionFUCHSIA",
85 "vkSetBufferCollectionImageConstraintsFUCHSIA",
86 "vkSetBufferCollectionBufferConstraintsFUCHSIA",
87 "vkGetBufferCollectionPropertiesFUCHSIA",
88 "vkSetPrivateData",
89 "vkSetPrivateDataKHR",
90 "vkGetPrivateData",
91 "vkGetPrivateDataKHR",
92 "vkCreatePrivateDataSlot",
93 "vkCreatePrivateDataSlotEXT",
94 "vkDestroyPrivateDataSlot",
95 "vkDestroyPrivateDataSlotEXT",
96 ]
97
98 SUCCESS_VAL = {
99 "VkResult" : ["VK_SUCCESS"],
100 }
101
102 # These could be entrypoints that are custom-written for gfxstream, or ones that
103 # are meant fall back to the vk_common_* entrypoints
104 NON_AUTOGEN_ENTRYPOINTS = [
105 # Instance/device/physical-device special-handling, dispatch tables, etc..
106 "vkCreateInstance",
107 "vkDestroyInstance",
108 "vkGetInstanceProcAddr",
109 "vkEnumerateInstanceVersion",
110 "vkEnumerateInstanceLayerProperties",
111 "vkEnumerateInstanceExtensionProperties",
112 "vkEnumerateDeviceExtensionProperties",
113 "vkGetDeviceProcAddr",
114 "vkEnumeratePhysicalDevices",
115 "vkEnumeratePhysicalDeviceGroups",
116 "vkCreateDevice",
117 "vkDestroyDevice",
118 # Manual alloc/free + vk_*_init/free() call w/ special params
119 # Command pool/buffer handling
120 "vkCreateCommandPool",
121 "vkDestroyCommandPool",
122 "vkAllocateCommandBuffers",
123 "vkResetCommandPool",
124 "vkFreeCommandBuffers",
125 "vkResetCommandPool",
126 # Transform feedback
127 "vkCmdBeginTransformFeedbackEXT",
128 # Special cases to handle struct translations in the pNext chain
129 # TODO: Make a codegen module (use deepcopy as reference) to make this more robust
130 "vkAllocateMemory",
131 "vkUpdateDescriptorSets",
132
133 # Use vk_common_* entrypoints; usually just dispatches to the "vk*2()" API variant
134 "vkGetDeviceQueue",
135 "vkGetDeviceQueue2",
136 "vkGetPhysicalDeviceProperties",
137 # Custom gfxstream functions
138 "vkMapMemoryIntoAddressSpaceGOOGLE",
139 "vkUpdateDescriptorSetWithTemplateSizedGOOGLE",
140 "vkBeginCommandBufferAsyncGOOGLE",
141 "vkEndCommandBufferAsyncGOOGLE",
142 "vkResetCommandBufferAsyncGOOGLE",
143 "vkCommandBufferHostSyncGOOGLE",
144 "vkCreateImageWithRequirementsGOOGLE",
145 "vkCreateBufferWithRequirementsGOOGLE",
146 "vkGetMemoryHostAddressInfoGOOGLE",
147 "vkGetPhysicalDeviceProperties2",
148 "vkFreeMemorySyncGOOGLE",
149 "vkQueueHostSyncGOOGLE",
150 "vkQueueSubmitAsyncGOOGLE",
151 "vkQueueWaitIdleAsyncGOOGLE",
152 "vkQueueBindSparseAsyncGOOGLE",
153 "vkGetLinearImageLayoutGOOGLE",
154 "vkGetLinearImageLayout2GOOGLE",
155 "vkQueueFlushCommandsGOOGLE",
156 "vkQueueCommitDescriptorSetUpdatesGOOGLE",
157 "vkCollectDescriptorPoolIdsGOOGLE",
158 "vkQueueSignalReleaseImageANDROIDAsyncGOOGLE",
159 "vkQueueFlushCommandsFromAuxMemoryGOOGLE",
160 "vkGetBlobGOOGLE",
161 "vkUpdateDescriptorSetWithTemplateSized2GOOGLE",
162 "vkQueueSubmitAsync2GOOGLE",
163 "vkGetSemaphoreGOOGLE",
164 "vkTraceAsyncGOOGLE",
165 "vkSetDebugMetadataAsyncGOOGLE",
166 ]
167
168 # Handles that need to be translated to/from their corresponding gfxstream object types
169 HANDLES_TRANSLATE = {
170 "VkInstance",
171 "VkPhysicalDevice",
172 "VkDevice",
173 "VkQueue",
174 "VkCommandPool",
175 "VkCommandBuffer",
176 "VkFence",
177 "VkSemaphore",
178 # TODO: Still need this translation to avoid descriptorSets crash
179 "VkBuffer",
180 }
181
182 # Types that have a corresponding method for transforming
183 # an input list to its internal counterpart
184 TYPES_TRANSFORM_LIST_METHOD = {
185 "VkFence",
186 "VkSemaphore",
187 "VkSemaphoreSubmitInfo",
188 }
189
190 def is_cmdbuf_dispatch(api):
191 return "VkCommandBuffer" == api.parameters[0].typeName
192
193 def is_queue_dispatch(api):
194 return "VkQueue" == api.parameters[0].typeName
195
196 def getCreateParam(api):
197 for param in api.parameters:
198 if param.isCreatedBy(api):
199 return param
200 return None
201
202 def getDestroyParam(api):
203 for param in api.parameters:
204 if param.isDestroyedBy(api):
205 return param
206 return None
207
208 # i.e. VkQueryPool --> vk_query_pool
209 def typeNameToMesaType(typeName):
210 vkTypeNameRegex = "(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])"
211 words = re.split(vkTypeNameRegex, typeName)
212 outputType = "vk"
213 for word in words[1:]:
214 outputType += "_"
215 outputType += word.lower()
216 return outputType
217
218 def typeNameToBaseName(typeName):
219 return typeNameToMesaType(typeName)[len("vk_"):]
220
221 def paramNameToObjectName(paramName):
222 return "gfxstream_%s" % paramName
223
224 def typeNameToVkObjectType(typeName):
225 return "VK_OBJECT_TYPE_%s" % typeNameToBaseName(typeName).upper()
226
227 def typeNameToObjectType(typeName):
228 return "gfxstream_vk_%s" % typeNameToBaseName(typeName)
229
230 def transformListFuncName(typeName):
231 return "transform%sList" % (typeName)
232
233 def isAllocatorParam(param):
234 ALLOCATOR_TYPE_NAME = "VkAllocationCallbacks"
235 return (param.pointerIndirectionLevels == 1
236 and param.isConst
237 and param.typeName == ALLOCATOR_TYPE_NAME)
238
239 def isArrayParam(param):
240 return (1 == param.pointerIndirectionLevels
241 and param.isConst
242 and "len" in param.attribs)
243
244 INTERNAL_OBJECT_NAME = "internal_object"
245
246 class VulkanFuncTable(VulkanWrapperGenerator):
247 def __init__(self, module, typeInfo):
248 VulkanWrapperGenerator.__init__(self, module, typeInfo)
249 self.typeInfo = typeInfo
250 self.cgen = CodeGen()
251 self.entries = []
252 self.entryFeatures = []
253 self.cmdToFeatureType = {}
254 self.feature = None
255 self.featureType = None
256
257 def onBegin(self,):
258 cgen = self.cgen
259 self.module.appendImpl(cgen.swapCode())
260 pass
261
262 def onBeginFeature(self, featureName, featureType):
263 self.feature = featureName
264 self.featureType = featureType
265
266 def onEndFeature(self):
267 self.feature = None
268 self.featureType = None
269
270 def onFeatureNewCmd(self, name):
271 self.cmdToFeatureType[name] = self.featureType
272
273 def onGenCmd(self, cmdinfo, name, alias):
274 typeInfo = self.typeInfo
275 cgen = self.cgen
276 api = typeInfo.apis[name]
277 self.entries.append(api)
278 self.entryFeatures.append(self.feature)
279 self.loopVars = ["i", "j", "k", "l", "m", "n"]
280 self.loopVarIndex = 0
281
282 def getNextLoopVar():
283 if self.loopVarIndex >= len(self.loopVars):
284 raise
285 loopVar = self.loopVars[self.loopVarIndex]
286 self.loopVarIndex += 1
287 return loopVar
288
289 def isCompoundType(typeName):
290 return typeInfo.isCompoundType(typeName)
291
292 def handleTranslationRequired(typeName):
293 return typeName in HANDLE_TYPES and typeName in HANDLES_TRANSLATE
294
295 def translationRequired(typeName):
296 if isCompoundType(typeName):
297 struct = typeInfo.structs[typeName]
298 for member in struct.members:
299 if translationRequired(member.typeName):
300 return True
301 return False
302 else:
303 return handleTranslationRequired(typeName)
304
305 def genDestroyGfxstreamObjects():
306 destroyParam = getDestroyParam(api)
307 if not destroyParam:
308 return
309 if not translationRequired(destroyParam.typeName):
310 return
311 objectName = paramNameToObjectName(destroyParam.paramName)
312 allocatorParam = "NULL"
313 for p in api.parameters:
314 if isAllocatorParam(p):
315 allocatorParam = p.paramName
316 deviceParam = api.parameters[0]
317 if "VkDevice" != deviceParam.typeName:
318 print("ERROR: Unhandled non-VkDevice parameters[0]: %s (for API: %s)" %(deviceParam.typeName, api.name))
319 raise
320 # call vk_object_free() directly
321 mesaObjectDestroy = "(void *)%s" % objectName
322 cgen.funcCall(
323 None,
324 "vk_object_free",
325 ["&%s->vk" % paramNameToObjectName(deviceParam.paramName), allocatorParam, mesaObjectDestroy]
326 )
327
328 def genMesaObjectAlloc(allocCallLhs):
329 deviceParam = api.parameters[0]
330 if "VkDevice" != deviceParam.typeName:
331 print("ERROR: Unhandled non-VkDevice parameters[0]: %s (for API: %s)" %(deviceParam.typeName, api.name))
332 raise
333 allocatorParam = "NULL"
334 for p in api.parameters:
335 if isAllocatorParam(p):
336 allocatorParam = p.paramName
337 createParam = getCreateParam(api)
338 objectType = typeNameToObjectType(createParam.typeName)
339 # Call vk_object_zalloc directly
340 cgen.funcCall(
341 allocCallLhs,
342 "(%s *)vk_object_zalloc" % objectType,
343 ["&%s->vk" % paramNameToObjectName(deviceParam.paramName), allocatorParam, ("sizeof(%s)" % objectType), typeNameToVkObjectType(createParam.typeName)]
344 )
345
346 # Alloc/create gfxstream_vk_* object
347 def genCreateGfxstreamObjects():
348 createParam = getCreateParam(api)
349 if not createParam:
350 return False
351 if not handleTranslationRequired(createParam.typeName):
352 return False
353 objectType = "struct %s" % typeNameToObjectType(createParam.typeName)
354 callLhs = "%s *%s" % (objectType, paramNameToObjectName(createParam.paramName))
355 genMesaObjectAlloc(callLhs)
356
357 retVar = api.getRetVarExpr()
358 if retVar:
359 retTypeName = api.getRetTypeExpr()
360 # ex: vkCreateBuffer_VkResult_return = gfxstream_buffer ? VK_SUCCESS : VK_ERROR_OUT_OF_HOST_MEMORY;
361 cgen.stmt("%s = %s ? %s : %s" %
362 (retVar, paramNameToObjectName(createParam.paramName), SUCCESS_VAL[retTypeName][0], "VK_ERROR_OUT_OF_HOST_MEMORY"))
363 return True
364
365 def genVkFromHandle(param, fromName):
366 objectName = paramNameToObjectName(param.paramName)
367 cgen.stmt("VK_FROM_HANDLE(%s, %s, %s)" %
368 (typeNameToObjectType(param.typeName), objectName, fromName))
369 return objectName
370
371 def genGetGfxstreamHandles():
372 createParam = getCreateParam(api)
373 for param in api.parameters:
374 if not handleTranslationRequired(param.typeName):
375 continue
376 elif isArrayParam(param):
377 continue
378 elif param != createParam:
379 if param.pointerIndirectionLevels > 0:
380 print("ERROR: Unhandled pointerIndirectionLevels > 1 for API %s (param %s)" % (api.name, param.paramName))
381 raise
382 genVkFromHandle(param, param.paramName)
383
384 def internalNestedParamName(param):
385 parentName = ""
386 if param.parent:
387 parentName = "_%s" % param.parent.typeName
388 return "internal%s_%s" % (parentName, param.paramName)
389
390 def genInternalArrayDeclarations(param, countParamName, nestLevel=0):
391 internalArray = None
392 if 0 == nestLevel:
393 internalArray = "internal_%s" % param.paramName
394 cgen.stmt("std::vector<%s> %s(%s)" % (param.typeName, internalArray, countParamName))
395 elif 1 == nestLevel or 2 == nestLevel:
396 internalArray = internalNestedParamName(param)
397 if isArrayParam(param):
398 cgen.stmt("std::vector<std::vector<%s>> %s" % (param.typeName, internalArray))
399 else:
400 cgen.stmt("std::vector<%s> %s" % (param.typeName, internalArray))
401 else:
402 print("ERROR: nestLevel > 2 not verified.")
403 raise
404 if isCompoundType(param.typeName):
405 for member in typeInfo.structs[param.typeName].members:
406 if translationRequired(member.typeName):
407 if handleTranslationRequired(member.typeName) and not isArrayParam(member):
408 # No declarations for non-array handleType
409 continue
410 genInternalArrayDeclarations(member, countParamName, nestLevel + 1)
411 return internalArray
412
413 def genInternalCompoundType(param, outName, inName, currLoopVar):
414 nextLoopVar = None
415 cgen.stmt("%s = %s" % (outName, inName))
416 for member in typeInfo.structs[param.typeName].members:
417 if not translationRequired(member.typeName):
418 continue
419 cgen.line("/* %s::%s */" % (param.typeName, member.paramName))
420 nestedOutName = ("%s[%s]" % (internalNestedParamName(member), currLoopVar))
421 if isArrayParam(member):
422 countParamName = "%s.%s" % (outName, member.attribs["len"])
423 inArrayName = "%s.%s" % (outName, member.paramName)
424 cgen.stmt("%s.push_back(std::vector<%s>())" % (internalNestedParamName(member), member.typeName))
425 if member.typeName in TYPES_TRANSFORM_LIST_METHOD:
426 # Use the corresponding transformList call
427 cgen.funcCall(nestedOutName, transformListFuncName(member.typeName), [inArrayName, countParamName])
428 cgen.stmt("%s = %s.data()" % (inArrayName, nestedOutName))
429 cgen.stmt("%s = %s.size()" % (countParamName, nestedOutName))
430 else:
431 # Standard translation
432 cgen.stmt("%s.resize(%s)" % (nestedOutName, countParamName))
433 if not nextLoopVar:
434 nextLoopVar = getNextLoopVar()
435 internalArray = genInternalArray(member, countParamName, nestedOutName, inArrayName, nextLoopVar)
436 cgen.stmt("%s = %s" %(inArrayName, internalArray))
437 elif isCompoundType(member.typeName):
438 memberFullName = "%s.%s" % (outName, member.paramName)
439 if 1 == member.pointerIndirectionLevels:
440 cgen.beginIf(memberFullName)
441 inParamName = "%s[0]" % memberFullName
442 genInternalCompoundType(member, nestedOutName, inParamName, currLoopVar)
443 cgen.stmt("%s.%s = &%s" % (outName, member.paramName, nestedOutName))
444 else:
445 cgen.beginBlock()
446 genInternalCompoundType(member, nestedOutName, memberFullName, currLoopVar)
447 cgen.stmt("%s.%s = %s" % (outName, member.paramName, nestedOutName))
448 cgen.endBlock()
449 else:
450 # Replace member with internal object
451 replaceName = "%s.%s" % (outName, member.paramName)
452 if member.isOptional:
453 cgen.beginIf(replaceName)
454 gfxstreamObject = genVkFromHandle(member, replaceName)
455 cgen.stmt("%s = %s->%s" % (replaceName, gfxstreamObject, INTERNAL_OBJECT_NAME))
456 if member.isOptional:
457 cgen.endIf()
458
459 def genInternalArray(param, countParamName, outArrayName, inArrayName, loopVar):
460 if param.typeName in TYPES_TRANSFORM_LIST_METHOD:
461 # Use the corresponding transformList call
462 cgen.funcCall(outArrayName, transformListFuncName(param.typeName), [inArrayName, countParamName])
463 cgen.stmt("%s = %s.data()" % (inArrayName, outArrayName))
464 cgen.stmt("%s = %s.size()" % (countParamName, outArrayName))
465 else:
466 cgen.beginFor("uint32_t %s = 0" % loopVar, "%s < %s" % (loopVar, countParamName), "++%s" % loopVar)
467 if param.isOptional:
468 cgen.beginIf(inArrayName)
469 if isCompoundType(param.typeName):
470 genInternalCompoundType(param, ("%s[%s]" % (outArrayName, loopVar)), "%s[%s]" % (inArrayName, loopVar), loopVar)
471 else:
472 gfxstreamObject = genVkFromHandle(param, "%s[%s]" % (inArrayName, loopVar))
473 cgen.stmt("%s[%s] = %s->%s" % (outArrayName, loopVar, gfxstreamObject, INTERNAL_OBJECT_NAME))
474 if param.isOptional:
475 cgen.endIf()
476 cgen.endFor()
477 return "%s.data()" % outArrayName
478
479 # Translate params into params needed for gfxstream-internal
480 # encoder/resource-tracker calls
481 def getEncoderOrResourceTrackerParams():
482 createParam = getCreateParam(api)
483 outParams = copy.deepcopy(api.parameters)
484 nextLoopVar = getNextLoopVar()
485 for param in outParams:
486 if not translationRequired(param.typeName):
487 continue
488 elif isArrayParam(param) or isCompoundType(param.typeName):
489 if param.possiblyOutput():
490 print("ERROR: Unhandled CompoundType / Array output for API %s (param %s)" % (api.name, param.paramName))
491 raise
492 if 1 != param.pointerIndirectionLevels or not param.isConst:
493 print("ERROR: Compound type / array input is not 'const <type>*' (API: %s, paramName: %s)" % (api.name, param.paramName))
494 raise
495 countParamName = "1"
496 if "len" in param.attribs:
497 countParamName = param.attribs["len"]
498 internalArrayName = genInternalArrayDeclarations(param, countParamName)
499 param.paramName = genInternalArray(param, countParamName, internalArrayName, param.paramName, nextLoopVar)
500 elif 0 == param.pointerIndirectionLevels:
501 if param.isOptional:
502 param.paramName = ("%s ? %s->%s : VK_NULL_HANDLE" % (paramNameToObjectName(param.paramName), paramNameToObjectName(param.paramName), INTERNAL_OBJECT_NAME))
503 else:
504 param.paramName = ("%s->%s" % (paramNameToObjectName(param.paramName), INTERNAL_OBJECT_NAME))
505 elif createParam and param.paramName == createParam.paramName:
506 param.paramName = ("&%s->%s" % (paramNameToObjectName(param.paramName), INTERNAL_OBJECT_NAME))
507 else:
508 print("ERROR: Unknown handling for param: %s (API: %s)" % (param, api.name))
509 raise
510 return outParams
511
512 def genEncoderOrResourceTrackerCall(declareResources=True):
513 if is_cmdbuf_dispatch(api):
514 cgen.stmt("auto vkEnc = gfxstream::vk::ResourceTracker::getCommandBufferEncoder(%s->%s)" % (paramNameToObjectName(api.parameters[0].paramName), INTERNAL_OBJECT_NAME))
515 elif is_queue_dispatch(api):
516 cgen.stmt("auto vkEnc = gfxstream::vk::ResourceTracker::getQueueEncoder(%s->%s)" % (paramNameToObjectName(api.parameters[0].paramName), INTERNAL_OBJECT_NAME))
517 else:
518 cgen.stmt("auto vkEnc = gfxstream::vk::ResourceTracker::getThreadLocalEncoder()")
519 callLhs = None
520 retTypeName = api.getRetTypeExpr()
521 if retTypeName != "void":
522 callLhs = api.getRetVarExpr()
523
524 # Get parameter list modded for gfxstream-internal call
525 parameters = getEncoderOrResourceTrackerParams()
526 if name in RESOURCE_TRACKER_ENTRIES:
527 if declareResources:
528 cgen.stmt("auto resources = gfxstream::vk::ResourceTracker::get()")
529 cgen.funcCall(
530 callLhs, "resources->" + "on_" + api.name,
531 ["vkEnc"] + SUCCESS_VAL.get(retTypeName, []) + \
532 [p.paramName for p in parameters])
533 else:
534 cgen.funcCall(
535 callLhs, "vkEnc->" + api.name, [p.paramName for p in parameters] + ["true /* do lock */"])
536
537 def genReturnExpression():
538 retTypeName = api.getRetTypeExpr()
539 # Set the createParam output, if applicable
540 createParam = getCreateParam(api)
541 if createParam and handleTranslationRequired(createParam.typeName):
542 if 1 != createParam.pointerIndirectionLevels:
543 print("ERROR: Unhandled pointerIndirectionLevels != 1 in return for API %s (createParam %s)" % api.name, createParam.paramName)
544 raise
545 # ex: *pBuffer = gfxstream_vk_buffer_to_handle(gfxstream_buffer)
546 cgen.funcCall(
547 "*%s" % createParam.paramName,
548 "%s_to_handle" % typeNameToObjectType(createParam.typeName),
549 [paramNameToObjectName(createParam.paramName)]
550 )
551
552 if retTypeName != "void":
553 cgen.stmt("return %s" % api.getRetVarExpr())
554
555 def genGfxstreamEntry(declareResources=True):
556 cgen.stmt("MESA_TRACE_SCOPE(\"%s\")" % api.name)
557 # declare returnVar
558 retTypeName = api.getRetTypeExpr()
559 retVar = api.getRetVarExpr()
560 if retVar:
561 cgen.stmt("%s %s = (%s)0" % (retTypeName, retVar, retTypeName))
562 # Check non-null destroy param for free/destroy calls
563 destroyParam = getDestroyParam(api)
564 if destroyParam:
565 cgen.beginIf("VK_NULL_HANDLE == %s" % destroyParam.paramName)
566 if api.getRetTypeExpr() != "void":
567 cgen.stmt("return %s" % api.getRetVarExpr())
568 else:
569 cgen.stmt("return")
570 cgen.endIf()
571 # Translate handles
572 genGetGfxstreamHandles()
573 # Translation/creation of objects
574 createdObject = genCreateGfxstreamObjects()
575 # Make encoder/resource-tracker call
576 if retVar and createdObject:
577 cgen.beginIf("%s == %s" % (SUCCESS_VAL[retTypeName][0], retVar))
578 else:
579 cgen.beginBlock()
580 genEncoderOrResourceTrackerCall()
581 cgen.endBlock()
582 # Destroy gfxstream objects
583 genDestroyGfxstreamObjects()
584 # Set output / return variables
585 genReturnExpression()
586
587 api_entry = api.withModifiedName("gfxstream_vk_" + api.name[2:])
588 if api.name not in NON_AUTOGEN_ENTRYPOINTS:
589 cgen.line(self.cgen.makeFuncProto(api_entry))
590 cgen.beginBlock()
591 genGfxstreamEntry()
592 cgen.endBlock()
593 self.module.appendImpl(cgen.swapCode())
594
595
596 def onEnd(self,):
597 pass
598
599 def isDeviceDispatch(self, api):
600 # TODO(230793667): improve the heuristic and just use "cmdToFeatureType"
601 return (len(api.parameters) > 0 and
602 "VkDevice" == api.parameters[0].typeName) or (
603 "VkCommandBuffer" == api.parameters[0].typeName and
604 self.cmdToFeatureType.get(api.name, "") == "device")