[Mesa-dev] [PATCH mesa 3/3] egl: remove dead code in glvnd dispatch generation code
Kyle Brenneman
kyle.brenneman at gmail.com
Wed Nov 7 17:12:35 UTC 2018
On 11/07/2018 06:20 AM, Eric Engestrom wrote:
> g_egldispatchstubs.[ch] are completely identical before and after this
> patch.
>
> Signed-off-by: Eric Engestrom <eric.engestrom at intel.com>
> ---
> src/egl/generate/eglFunctionList.py | 203 +++++++++++----------------
> src/egl/generate/gen_egl_dispatch.py | 61 ++------
> 2 files changed, 91 insertions(+), 173 deletions(-)
>
> diff --git a/src/egl/generate/eglFunctionList.py b/src/egl/generate/eglFunctionList.py
> index 667704eb2cb46fd06ff2..a480efca0d77a956dd78 100644
> --- a/src/egl/generate/eglFunctionList.py
> +++ b/src/egl/generate/eglFunctionList.py
> @@ -5,36 +5,10 @@
>
> This is used from gen_egl_dispatch.py.
>
> -EGL_FUNCTIONS is a sequence of (name, eglData) pairs, where name is the name
> -of the function, and eglData is a dictionary containing data about that
> -function.
> +EGL_FUNCTIONS is a sequence of (name, method) pairs, where name is the name
> +of the function, and method is a string describing how to select a vendor
> +library for that function:
>
> -The values in the eglData dictionary are:
> -- method (string):
> - How to select a vendor library. See "Method values" below.
> -
> -- prefix (string):
> - This string is prepended to the name of the dispatch function. If
> - unspecified, the default is "" (an empty string).
> -
> -- static (boolean)
> - If True, this function should be declared static.
> -
> -- "public" (boolean)
> - If True, the function should be exported from the library. Vendor libraries
> - generally should not use this.
> -
> -- extension (string):
> - If specified, this is the name of a macro to check for before defining a
> - function. Used for checking for extension macros and such.
> -
> -- retval (string):
> - If specified, this is a C expression with the default value to return if we
> - can't find a function to call. By default, it will try to guess from the
> - return type: EGL_NO_whatever for the various handle types, NULL for
> - pointers, and zero for everything else.
> -
> -method values:
> - "custom"
> The dispatch stub will be hand-written instead of generated.
>
> @@ -53,158 +27,139 @@
> Select the vendor that owns the current context.
> """
>
> -def _eglFunc(name, method, static=None, public=False, inheader=None, prefix="dispatch_", extension=None, retval=None):
> - """
> - A convenience function to define an entry in the EGL function list.
> - """
> - if static is None:
> - static = (not public and method != "custom")
> - if inheader is None:
> - inheader = (not static)
> - values = {
> - "method" : method,
> - "prefix" : prefix,
> - "extension" : extension,
> - "retval" : retval,
> - "static" : static,
> - "public" : public,
> - "inheader" : inheader,
> - }
> - return (name, values)
> -
> EGL_FUNCTIONS = (
> # EGL_VERSION_1_0
> - _eglFunc("eglChooseConfig", "none"),
> - _eglFunc("eglCopyBuffers", "none"),
> - _eglFunc("eglCreateContext", "none"),
> - _eglFunc("eglCreatePbufferSurface", "none"),
> - _eglFunc("eglCreatePixmapSurface", "none"),
> - _eglFunc("eglCreateWindowSurface", "none"),
> - _eglFunc("eglDestroyContext", "none"),
> - _eglFunc("eglDestroySurface", "none"),
> - _eglFunc("eglGetConfigAttrib", "none"),
> - _eglFunc("eglGetConfigs", "none"),
> - _eglFunc("eglQueryContext", "none"),
> - _eglFunc("eglQuerySurface", "none"),
> - _eglFunc("eglSwapBuffers", "none"),
> - _eglFunc("eglWaitGL", "none"),
> - _eglFunc("eglWaitNative", "none"),
> - _eglFunc("eglTerminate", "none"),
> - _eglFunc("eglInitialize", "none"),
> + ("eglChooseConfig", "none"),
> + ("eglCopyBuffers", "none"),
> + ("eglCreateContext", "none"),
> + ("eglCreatePbufferSurface", "none"),
> + ("eglCreatePixmapSurface", "none"),
> + ("eglCreateWindowSurface", "none"),
> + ("eglDestroyContext", "none"),
> + ("eglDestroySurface", "none"),
> + ("eglGetConfigAttrib", "none"),
> + ("eglGetConfigs", "none"),
> + ("eglQueryContext", "none"),
> + ("eglQuerySurface", "none"),
> + ("eglSwapBuffers", "none"),
> + ("eglWaitGL", "none"),
> + ("eglWaitNative", "none"),
> + ("eglTerminate", "none"),
> + ("eglInitialize", "none"),
>
> - _eglFunc("eglGetCurrentDisplay", "none"),
> - _eglFunc("eglGetCurrentSurface", "none"),
> - _eglFunc("eglGetDisplay", "none"),
> - _eglFunc("eglGetError", "none"),
> - _eglFunc("eglGetProcAddress", "none"),
> - _eglFunc("eglMakeCurrent", "none"),
> - _eglFunc("eglQueryString", "none"),
> + ("eglGetCurrentDisplay", "none"),
> + ("eglGetCurrentSurface", "none"),
> + ("eglGetDisplay", "none"),
> + ("eglGetError", "none"),
> + ("eglGetProcAddress", "none"),
> + ("eglMakeCurrent", "none"),
> + ("eglQueryString", "none"),
>
> # EGL_VERSION_1_1
> - _eglFunc("eglBindTexImage", "none"),
> - _eglFunc("eglReleaseTexImage", "none"),
> - _eglFunc("eglSurfaceAttrib", "none"),
> - _eglFunc("eglSwapInterval", "none"),
> + ("eglBindTexImage", "none"),
> + ("eglReleaseTexImage", "none"),
> + ("eglSurfaceAttrib", "none"),
> + ("eglSwapInterval", "none"),
>
> # EGL_VERSION_1_2
> - _eglFunc("eglCreatePbufferFromClientBuffer", "none"),
> - _eglFunc("eglWaitClient", "none"),
> - _eglFunc("eglBindAPI", "none"),
> - _eglFunc("eglQueryAPI", "none"),
> - _eglFunc("eglReleaseThread", "none"),
> + ("eglCreatePbufferFromClientBuffer", "none"),
> + ("eglWaitClient", "none"),
> + ("eglBindAPI", "none"),
> + ("eglQueryAPI", "none"),
> + ("eglReleaseThread", "none"),
>
> # EGL_VERSION_1_4
> - _eglFunc("eglGetCurrentContext", "none"),
> + ("eglGetCurrentContext", "none"),
>
> # EGL_VERSION_1_5
> - _eglFunc("eglCreateSync", "none"),
> - _eglFunc("eglDestroySync", "none"),
> - _eglFunc("eglClientWaitSync", "none"),
> - _eglFunc("eglGetSyncAttrib", "none"),
> - _eglFunc("eglCreateImage", "none"),
> - _eglFunc("eglDestroyImage", "none"),
> - _eglFunc("eglCreatePlatformWindowSurface", "none"),
> - _eglFunc("eglCreatePlatformPixmapSurface", "none"),
> - _eglFunc("eglWaitSync", "none"),
> - _eglFunc("eglGetPlatformDisplay", "none"),
> + ("eglCreateSync", "none"),
> + ("eglDestroySync", "none"),
> + ("eglClientWaitSync", "none"),
> + ("eglGetSyncAttrib", "none"),
> + ("eglCreateImage", "none"),
> + ("eglDestroyImage", "none"),
> + ("eglCreatePlatformWindowSurface", "none"),
> + ("eglCreatePlatformPixmapSurface", "none"),
> + ("eglWaitSync", "none"),
> + ("eglGetPlatformDisplay", "none"),
>
> # EGL_EXT_platform_base
> - _eglFunc("eglCreatePlatformWindowSurfaceEXT", "display"),
> - _eglFunc("eglCreatePlatformPixmapSurfaceEXT", "display"),
> - _eglFunc("eglGetPlatformDisplayEXT", "none"),
> + ("eglCreatePlatformWindowSurfaceEXT", "display"),
> + ("eglCreatePlatformPixmapSurfaceEXT", "display"),
> + ("eglGetPlatformDisplayEXT", "none"),
>
> # TODO: Most of these extensions should be provided by the vendor
> # libraries, not by libEGL. They're here now to make testing everything
> # else easier.
>
> # EGL_EXT_swap_buffers_with_damage
> - _eglFunc("eglSwapBuffersWithDamageEXT", "display"),
> + ("eglSwapBuffersWithDamageEXT", "display"),
>
> # KHR_EXT_swap_buffers_with_damage
> - _eglFunc("eglSwapBuffersWithDamageKHR", "display"),
> + ("eglSwapBuffersWithDamageKHR", "display"),
>
> # EGL_KHR_cl_event2
> - _eglFunc("eglCreateSync64KHR", "display"),
> + ("eglCreateSync64KHR", "display"),
>
> # EGL_KHR_fence_sync
> - _eglFunc("eglCreateSyncKHR", "display"),
> - _eglFunc("eglDestroySyncKHR", "display"),
> - _eglFunc("eglClientWaitSyncKHR", "display"),
> - _eglFunc("eglGetSyncAttribKHR", "display"),
> + ("eglCreateSyncKHR", "display"),
> + ("eglDestroySyncKHR", "display"),
> + ("eglClientWaitSyncKHR", "display"),
> + ("eglGetSyncAttribKHR", "display"),
>
> # EGL_KHR_image
> - _eglFunc("eglCreateImageKHR", "display"),
> - _eglFunc("eglDestroyImageKHR", "display"),
> + ("eglCreateImageKHR", "display"),
> + ("eglDestroyImageKHR", "display"),
>
> # EGL_KHR_image_base
> # eglCreateImageKHR already defined in EGL_KHR_image
> # eglDestroyImageKHR already defined in EGL_KHR_image
>
> # EGL_KHR_reusable_sync
> - _eglFunc("eglSignalSyncKHR", "display"),
> + ("eglSignalSyncKHR", "display"),
> # eglCreateSyncKHR already defined in EGL_KHR_fence_sync
> # eglDestroySyncKHR already defined in EGL_KHR_fence_sync
> # eglClientWaitSyncKHR already defined in EGL_KHR_fence_sync
> # eglGetSyncAttribKHR already defined in EGL_KHR_fence_sync
>
> # EGL_KHR_wait_sync
> - _eglFunc("eglWaitSyncKHR", "display"),
> + ("eglWaitSyncKHR", "display"),
>
> # EGL_MESA_drm_image
> - _eglFunc("eglCreateDRMImageMESA", "display"),
> - _eglFunc("eglExportDRMImageMESA", "display"),
> + ("eglCreateDRMImageMESA", "display"),
> + ("eglExportDRMImageMESA", "display"),
>
> # EGL_MESA_image_dma_buf_export
> - _eglFunc("eglExportDMABUFImageQueryMESA", "display"),
> - _eglFunc("eglExportDMABUFImageMESA", "display"),
> + ("eglExportDMABUFImageQueryMESA", "display"),
> + ("eglExportDMABUFImageMESA", "display"),
>
> # EGL_NOK_swap_region
> - _eglFunc("eglSwapBuffersRegionNOK", "display"),
> + ("eglSwapBuffersRegionNOK", "display"),
>
> # EGL_NV_post_sub_buffer
> - _eglFunc("eglPostSubBufferNV", "display"),
> + ("eglPostSubBufferNV", "display"),
>
> # EGL_WL_bind_wayland_display
> - _eglFunc("eglCreateWaylandBufferFromImageWL", "display"),
> - _eglFunc("eglUnbindWaylandDisplayWL", "display"),
> - _eglFunc("eglQueryWaylandBufferWL", "display"),
> - _eglFunc("eglBindWaylandDisplayWL", "display"),
> + ("eglCreateWaylandBufferFromImageWL", "display"),
> + ("eglUnbindWaylandDisplayWL", "display"),
> + ("eglQueryWaylandBufferWL", "display"),
> + ("eglBindWaylandDisplayWL", "display"),
>
> # EGL_CHROMIUM_get_sync_values
> - _eglFunc("eglGetSyncValuesCHROMIUM", "display"),
> + ("eglGetSyncValuesCHROMIUM", "display"),
>
> # EGL_ANDROID_native_fence_sync
> - _eglFunc("eglDupNativeFenceFDANDROID", "display"),
> + ("eglDupNativeFenceFDANDROID", "display"),
>
> # EGL_EXT_image_dma_buf_import_modifiers
> - _eglFunc("eglQueryDmaBufFormatsEXT", "display"),
> - _eglFunc("eglQueryDmaBufModifiersEXT", "display"),
> + ("eglQueryDmaBufFormatsEXT", "display"),
> + ("eglQueryDmaBufModifiersEXT", "display"),
>
> # EGL_EXT_device_base
> - _eglFunc("eglQueryDeviceAttribEXT", "device"),
> - _eglFunc("eglQueryDeviceStringEXT", "device"),
> - _eglFunc("eglQueryDevicesEXT", "none"),
> - _eglFunc("eglQueryDisplayAttribEXT", "display"),
> + ("eglQueryDeviceAttribEXT", "device"),
> + ("eglQueryDeviceStringEXT", "device"),
> + ("eglQueryDevicesEXT", "none"),
> + ("eglQueryDisplayAttribEXT", "display"),
>
> )
>
> diff --git a/src/egl/generate/gen_egl_dispatch.py b/src/egl/generate/gen_egl_dispatch.py
> index 0c4d2956eff28911336c..d40774ddd853a4de4140 100644
> --- a/src/egl/generate/gen_egl_dispatch.py
> +++ b/src/egl/generate/gen_egl_dispatch.py
> @@ -56,9 +56,9 @@ def main():
> xmlFunctions = genCommon.getFunctions(args.xml_files)
> xmlByName = dict((f.name, f) for f in xmlFunctions)
> functions = []
> - for (name, eglFunc) in eglFunctionList.EGL_FUNCTIONS:
> + for (name, method) in eglFunctionList.EGL_FUNCTIONS:
> func = xmlByName[name]
> - eglFunc = fixupEglFunc(func, eglFunc)
> + eglFunc = fixupEglFunc(func, method)
> functions.append((func, eglFunc))
>
> # Sort the function list by name.
> @@ -70,24 +70,17 @@ def main():
> text = generateSource(functions)
> sys.stdout.write(text)
>
> -def fixupEglFunc(func, eglFunc):
> - result = dict(eglFunc)
> - if result.get("prefix") is None:
> - result["prefix"] = ""
> +def fixupEglFunc(func, method):
> + result = {"method": method}
>
> - if result.get("extension") is not None:
> - text = "defined(" + result["extension"] + ")"
> - result["extension"] = text
> -
> - if result["method"] in ("none", "custom"):
> + if result["method"] is "none":
> return result
>
> if result["method"] not in ("display", "device", "current"):
> raise ValueError("Invalid dispatch method %r for function %r" % (result["method"], func.name))
>
> if func.hasReturn():
> - if result.get("retval") is None:
> - result["retval"] = getDefaultReturnValue(func.rt)
> + result["retval"] = getDefaultReturnValue(func.rt)
>
> return result
>
> @@ -107,19 +100,11 @@ def generateHeader(functions):
> """.lstrip("\n"))
>
> text += "enum {\n"
> - for (func, eglFunc) in functions:
> - text += generateGuardBegin(func, eglFunc)
> + for (func, _) in functions:
> text += " __EGL_DISPATCH_" + func.name + ",\n"
> - text += generateGuardEnd(func, eglFunc)
> text += " __EGL_DISPATCH_COUNT\n"
> text += "};\n"
>
> - for (func, eglFunc) in functions:
> - if eglFunc["inheader"]:
> - text += generateGuardBegin(func, eglFunc)
> - text += "{f.rt} EGLAPIENTRY {ex[prefix]}{f.name}({f.decArgs});\n".format(f=func, ex=eglFunc)
> - text += generateGuardEnd(func, eglFunc)
> -
> text += textwrap.dedent(r"""
> #ifdef __cplusplus
> }
> @@ -137,58 +122,36 @@ def generateSource(functions):
>
> for (func, eglFunc) in functions:
> if eglFunc["method"] not in ("custom", "none"):
> - text += generateGuardBegin(func, eglFunc)
> text += generateDispatchFunc(func, eglFunc)
> - text += generateGuardEnd(func, eglFunc)
>
> text += "\n"
> text += "const char * const __EGL_DISPATCH_FUNC_NAMES[__EGL_DISPATCH_COUNT + 1] = {\n"
> - for (func, eglFunc) in functions:
> - text += generateGuardBegin(func, eglFunc)
> + for (func, _) in functions:
> text += ' "' + func.name + '",\n'
> - text += generateGuardEnd(func, eglFunc)
> text += " NULL\n"
> text += "};\n"
>
> text += "const __eglMustCastToProperFunctionPointerType __EGL_DISPATCH_FUNCS[__EGL_DISPATCH_COUNT + 1] = {\n"
> for (func, eglFunc) in functions:
> - text += generateGuardBegin(func, eglFunc)
> if eglFunc["method"] != "none":
> - text += " (__eglMustCastToProperFunctionPointerType) " + eglFunc.get("prefix", "") + func.name + ",\n"
> + text += " (__eglMustCastToProperFunctionPointerType) dispatch_" + func.name + ",\n"
> else:
> text += " NULL, // " + func.name + "\n"
> - text += generateGuardEnd(func, eglFunc)
> text += " NULL\n"
> text += "};\n"
>
> return text
>
> -def generateGuardBegin(func, eglFunc):
> - ext = eglFunc.get("extension")
> - if ext is not None:
> - return "#if " + ext + "\n"
> - else:
> - return ""
> -
> -def generateGuardEnd(func, eglFunc):
> - if eglFunc.get("extension") is not None:
> - return "#endif\n"
> - else:
> - return ""
> -
> def generateDispatchFunc(func, eglFunc):
> text = ""
>
> - if eglFunc.get("static"):
> - text += "static "
> - elif eglFunc.get("public"):
> - text += "PUBLIC "
> + text += "static "
> text += textwrap.dedent(
> r"""
> - {f.rt} EGLAPIENTRY {ef[prefix]}{f.name}({f.decArgs})
> + {f.rt} EGLAPIENTRY dispatch_{f.name}({f.decArgs})
> {{
> typedef {f.rt} EGLAPIENTRY (* _pfn_{f.name})({f.decArgs});
> - """).lstrip("\n").format(f=func, ef=eglFunc)
> + """).lstrip("\n").format(f=func)
>
> if func.hasReturn():
> text += " {f.rt} _ret = {ef[retval]};\n".format(f=func, ef=eglFunc)
This looks reasonable to me. You'd lose the ability to override the
error return value, but other than that, most of the extra parameters
aren't likely to be useful to Mesa.
Without all of the other parameters, you could pretty easily remove
fixupEglFunc entirely if you wanted to. The only thing in there that's
used anymore is getDefaultReturnValue, which you could call directly.
-Kyle
More information about the mesa-dev
mailing list