| from .common.codegen import CodeGen, VulkanWrapperGenerator |
| from .common.vulkantypes import VulkanAPI, iterateVulkanType, VulkanType |
| |
| from .reservedmarshaling import VulkanReservedMarshalingCodegen |
| from .transform import TransformCodegen |
| |
| from .wrapperdefs import API_PREFIX_RESERVEDUNMARSHAL |
| from .wrapperdefs import MAX_PACKET_LENGTH |
| from .wrapperdefs import ROOT_TYPE_DEFAULT_VALUE |
| |
| |
| decoder_decl_preamble = """ |
| """ |
| |
| decoder_impl_preamble = """ |
| """ |
| |
| global_state_prefix = "this->on_" |
| |
| READ_STREAM = "readStream" |
| WRITE_STREAM = "vkStream" |
| |
| # Driver workarounds for APIs that don't work well multithreaded |
| driver_workarounds_global_lock_apis = [ |
| "vkCreatePipelineLayout", |
| "vkDestroyPipelineLayout", |
| ] |
| |
| MAX_STACK_ITEMS = "16" |
| |
| |
| def emit_param_decl_for_reading(param, cgen): |
| if param.staticArrExpr: |
| cgen.stmt( |
| cgen.makeRichCTypeDecl(param.getForNonConstAccess())) |
| else: |
| cgen.stmt( |
| cgen.makeRichCTypeDecl(param)) |
| |
| if param.pointerIndirectionLevels > 0: |
| lenAccess = cgen.generalLengthAccess(param) |
| if not lenAccess: |
| lenAccess = "1" |
| 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)) |
| |
| |
| 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, |
| "", |
| direction="read", |
| dynAlloc=True)) |
| 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)) |
| 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.endFor() |
| if lenAccessGuard is not None: |
| self.cgen.endIf() |
| else: |
| if noUnbox: |
| cgen.line("// No unbox for %s" % (param.paramName)) |
| |
| lenAccess = cgen.generalLengthAccess(param) |
| if not lenAccess: |
| lenAccess = "1" |
| arrSize = "1" if "1" == lenAccess else "MAX_STACK_ITEMS" |
| |
| iterateVulkanType(typeInfo, param, VulkanReservedMarshalingCodegen( |
| cgen, |
| READ_STREAM, |
| ROOT_TYPE_DEFAULT_VALUE, |
| param.paramName, |
| "readStreamPtrPtr", |
| API_PREFIX_RESERVEDUNMARSHAL, |
| "" if (output or noUnbox) else "unbox_", |
| direction="read", |
| dynAlloc=True, |
| 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) |
| iterateVulkanType(typeInfo, param, VulkanReservedMarshalingCodegen( |
| cgen, |
| READ_STREAM, |
| ROOT_TYPE_DEFAULT_VALUE, |
| param.paramName, |
| "readStreamPtrPtr", |
| API_PREFIX_RESERVEDUNMARSHAL, |
| "", |
| direction="read", |
| dynAlloc=True)) |
| else: |
| 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, |
| "", |
| direction="read", |
| dynAlloc=True)) |
| cgen.stmt("auto unboxed_%s = unbox_%s(%s)" % |
| (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) |
| |
| |
| def emit_transform(typeInfo, param, cgen, variant="tohost"): |
| res = \ |
| 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: VulkanAPI): |
| self.params: list[VulkanType] = [] |
| self.toRead: list[VulkanType] = [] |
| self.toWrite: list[VulkanType] = [] |
| |
| for i, param in enumerate(api.parameters[1:]): |
| if i == 0 and param.isDispatchableHandleType(): |
| param.dispatchHandle = True |
| |
| if param.isNonDispatchableHandleType() and param.isCreatedBy(api): |
| param.nonDispatchableHandleCreate = True |
| |
| if param.isNonDispatchableHandleType() and param.isDestroyedBy(api): |
| param.nonDispatchableHandleDestroy = True |
| |
| if param.isDispatchableHandleType() and param.isCreatedBy(api): |
| param.dispatchableHandleCreate = True |
| |
| if param.isDispatchableHandleType() and param.isDestroyedBy(api): |
| param.dispatchableHandleDestroy = True |
| |
| self.toRead.append(param) |
| |
| if param.possiblyOutput(): |
| self.toWrite.append(param) |
| |
| self.params.append(param) |
| |
| |
| def emit_call_log(api, cgen): |
| decodingParams = DecodingParameters(api) |
| paramsToRead = decodingParams.toRead |
| |
| # cgen.beginIf("m_logCalls") |
| paramLogFormat = "%p" |
| paramLogArgs = ["(void*)boxed_dispatchHandle"] |
| |
| for p in paramsToRead: |
| paramLogFormat += "0x%llx " |
| for p in paramsToRead: |
| paramLogArgs.append("(unsigned long long)%s" % (p.paramName)) |
| # 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) |
| |
| paramsToRead = decodingParams.toRead |
| |
| for p in paramsToRead: |
| emit_param_decl_for_reading(p, cgen) |
| |
| i = 0 |
| for p in paramsToRead: |
| lenAccess = cgen.generalLengthAccess(p) |
| |
| if p.dispatchHandle: |
| emit_dispatch_unmarshal(typeInfo, p, cgen, globalWrapped) |
| else: |
| destroy = p.nonDispatchableHandleDestroy or p.dispatchableHandleDestroy |
| noUnbox = False |
| |
| if p.nonDispatchableHandleDestroy or p.dispatchableHandleDestroy: |
| destroy = True |
| 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)) |
| 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)) |
| |
| if p.possiblyOutput(): |
| 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) |
| i += 1 |
| |
| for p in paramsToRead: |
| emit_transform(typeInfo, p, cgen, variant="tohost") |
| |
| emit_call_log(api, cgen) |
| |
| |
| def emit_dispatch_call(api, cgen): |
| |
| decodingParams = DecodingParameters(api) |
| |
| customParams = ["(VkCommandBuffer)dispatchHandle"] |
| |
| for (i, p) in enumerate(api.parameters[1:]): |
| customParam = p.paramName |
| if decodingParams.params[i].dispatchHandle: |
| customParam = "unboxed_%s" % p.paramName |
| customParams.append(customParam) |
| |
| if api.name in driver_workarounds_global_lock_apis: |
| cgen.stmt("lock()") |
| |
| cgen.vkApiCall(api, customPrefix="vk->", customParameters=customParams, |
| checkForDeviceLost=True, globalStatePrefix=global_state_prefix, |
| checkForOutOfMemory=True) |
| |
| if api.name in driver_workarounds_global_lock_apis: |
| cgen.stmt("unlock()") |
| |
| |
| def emit_global_state_wrapped_call(api, cgen, context=False): |
| customParams = ["pool", "(VkCommandBuffer)(boxed_dispatchHandle)"] + \ |
| list(map(lambda p: p.paramName, api.parameters[1:])) |
| if context: |
| customParams += ["context"]; |
| cgen.vkApiCall(api, customPrefix=global_state_prefix, |
| customParameters=customParams, checkForDeviceLost=True, |
| checkForOutOfMemory=True, globalStatePrefix=global_state_prefix) |
| |
| |
| 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) |
| |
| def emit_global_state_wrapped_decoding_with_context(typeInfo, api, cgen): |
| emit_decode_parameters(typeInfo, api, cgen, globalWrapped=True) |
| emit_global_state_wrapped_call(api, cgen, context=True) |
| |
| custom_decodes = { |
| "vkCmdCopyBufferToImage": emit_global_state_wrapped_decoding_with_context, |
| "vkCmdCopyImage": emit_global_state_wrapped_decoding, |
| "vkCmdCopyImageToBuffer": emit_global_state_wrapped_decoding, |
| "vkCmdExecuteCommands": emit_global_state_wrapped_decoding, |
| "vkBeginCommandBuffer": emit_global_state_wrapped_decoding_with_context, |
| "vkEndCommandBuffer": emit_global_state_wrapped_decoding_with_context, |
| "vkResetCommandBuffer": emit_global_state_wrapped_decoding, |
| "vkCmdPipelineBarrier": emit_global_state_wrapped_decoding, |
| "vkCmdBindPipeline": emit_global_state_wrapped_decoding, |
| "vkCmdBindDescriptorSets": emit_global_state_wrapped_decoding, |
| "vkCmdCopyQueryPoolResults": emit_global_state_wrapped_decoding, |
| "vkBeginCommandBufferAsyncGOOGLE": emit_global_state_wrapped_decoding_with_context, |
| "vkEndCommandBufferAsyncGOOGLE": emit_global_state_wrapped_decoding_with_context, |
| "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) |
| self.typeInfo = typeInfo |
| self.cgen = CodeGen() |
| |
| def onBegin(self,): |
| self.module.appendImpl( |
| "#define MAX_STACK_ITEMS %s\n" % MAX_STACK_ITEMS) |
| |
| self.module.appendImpl( |
| "#define MAX_PACKET_LENGTH %s\n" % MAX_PACKET_LENGTH) |
| |
| self.module.appendImpl( |
| "size_t subDecode(VulkanMemReadingStream* readStream, VulkanDispatch* vk, void* boxed_dispatchHandle, void* dispatchHandle, VkDeviceSize dataSize, const void* pData, const VkDecoderContext& context)\n") |
| |
| self.cgen.beginBlock() # function body |
| |
| self.cgen.stmt("auto& metricsLogger = *context.metricsLogger") |
| 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.line("while (end - ptr >= 8)") |
| self.cgen.beginBlock() # while loop |
| |
| self.cgen.stmt("uint32_t opcode = *(uint32_t *)ptr") |
| self.cgen.stmt("uint32_t packetLen = *(uint32_t *)(ptr + 4)") |
| self.cgen.line(""" |
| // packetLen should be at least 8 (op code and packet length) and should not be excessively large |
| if (packetLen < 8 || packetLen > MAX_PACKET_LENGTH) { |
| WARN("Bad packet length %d detected, subdecode may fail", packetLen); |
| metricsLogger.logMetricEvent(MetricEventBadPacketLength{ .len = packetLen }); |
| } |
| """) |
| 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.line("switch (opcode)") |
| self.cgen.beginBlock() # switch stmt |
| |
| self.module.appendImpl(self.cgen.swapCode()) |
| |
| def onGenCmd(self, cmdinfo, name, alias): |
| typeInfo = self.typeInfo |
| cgen = self.cgen |
| api = typeInfo.apis[name] |
| |
| if "commandBuffer" != api.parameters[0].paramName: |
| return |
| |
| cgen.line("case OP_%s:" % name) |
| cgen.beginBlock() |
| cgen.stmt("android::base::beginTrace(\"%s subdecode\")" % name) |
| |
| if api.name in custom_decodes.keys(): |
| custom_decodes[api.name](typeInfo, api, cgen) |
| else: |
| emit_default_decoding(typeInfo, api, cgen) |
| |
| cgen.stmt("android::base::endTrace()") |
| cgen.stmt("break") |
| cgen.endBlock() |
| self.module.appendImpl(self.cgen.swapCode()) |
| |
| def onEnd(self,): |
| self.cgen.line("default:") |
| self.cgen.beginBlock() |
| self.cgen.stmt( |
| "GFXSTREAM_ABORT(::emugl::FatalError(::emugl::ABORT_REASON_OTHER)) << \"Unrecognized opcode \" << opcode") |
| self.cgen.endBlock() |
| |
| 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.stmt("pool->freeAll()") |
| self.cgen.stmt("return ptr - (unsigned char*)buf;") |
| self.cgen.endBlock() # function body |
| self.module.appendImpl(self.cgen.swapCode()) |
