X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmapi%2Fglapi%2Fgen%2Fgl_gentable.py;h=92e1a546cffc0978c20b66096344e951c40a2a5c;hb=50533d408db1048a148012e2c3e1be5aca2ae93d;hp=814238a76e1bd06997e8a202b16b184e2f6f5885;hpb=1e16c34c5c86690b26739fbad82617768b1bd837;p=mesa.git diff --git a/src/mapi/glapi/gen/gl_gentable.py b/src/mapi/glapi/gen/gl_gentable.py index 814238a76e1..92e1a546cff 100644 --- a/src/mapi/glapi/gen/gl_gentable.py +++ b/src/mapi/glapi/gen/gl_gentable.py @@ -1,7 +1,7 @@ -#!/usr/bin/env python # (C) Copyright IBM Corporation 2004, 2005 # (C) Copyright Apple Inc. 2011 +# Copyright (C) 2015 Intel Corporation # All Rights Reserved. # # Permission is hereby granted, free of charge, to any person obtaining a @@ -29,29 +29,58 @@ # Based on code ogiginally by: # Ian Romanick +from __future__ import print_function + +import argparse + import license import gl_XML, glX_XML -import sys, getopt -header = """ -#if defined(DEBUG) && !defined(_WIN32_WCE) +header = """/* GLXEXT is the define used in the xserver when the GLX extension is being + * built. Hijack this to determine whether this file is being built for the + * server or the client. + */ +#ifdef HAVE_DIX_CONFIG_H +#include +#endif + +#if (defined(GLXEXT) && defined(HAVE_BACKTRACE)) \\ + || (!defined(GLXEXT) && defined(DEBUG) && defined(HAVE_EXECINFO_H)) +#define USE_BACKTRACE +#endif + +#ifdef USE_BACKTRACE #include #endif +#ifndef _WIN32 #include +#endif #include #include +#include -#include +#include "main/glheader.h" #include "glapi.h" #include "glapitable.h" +#ifdef GLXEXT +#include "os.h" +#endif + static void __glapi_gentable_NoOp(void) { -#if defined(DEBUG) && !defined(_WIN32_WCE) - if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG")) { - const char *fstr = "Unknown"; + const char *fstr = "Unknown"; + + /* Silence potential GCC warning for some #ifdef paths. + */ + (void) fstr; +#if defined(USE_BACKTRACE) +#if !defined(GLXEXT) + if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG")) +#endif + { void *frames[2]; if(backtrace(frames, 2) == 2) { @@ -61,16 +90,21 @@ __glapi_gentable_NoOp(void) { fstr = info.dli_sname; } +#if !defined(GLXEXT) fprintf(stderr, "Call to unimplemented API: %s\\n", fstr); +#endif } #endif +#if defined(GLXEXT) + LogMessage(X_ERROR, "GLX: Call to unimplemented API: %s\\n", fstr); +#endif } static void __glapi_gentable_set_remaining_noop(struct _glapi_table *disp) { GLuint entries = _glapi_get_dispatch_table_size(); void **dispatch = (void **) disp; - int i; + unsigned i; /* ISO C is annoying sometimes */ union {_glapi_proc p; void *v;} p; @@ -81,9 +115,12 @@ __glapi_gentable_set_remaining_noop(struct _glapi_table *disp) { dispatch[i] = p.v; } +""" + +footer = """ struct _glapi_table * _glapi_create_table_from_handle(void *handle, const char *symbol_prefix) { - struct _glapi_table *disp = calloc(1, sizeof(struct _glapi_table)); + struct _glapi_table *disp = calloc(_glapi_get_dispatch_table_size(), sizeof(_glapi_proc)); char symboln[512]; if(!disp) @@ -91,84 +128,127 @@ _glapi_create_table_from_handle(void *handle, const char *symbol_prefix) { if(symbol_prefix == NULL) symbol_prefix = ""; -""" -footer = """ + /* Note: This code relies on _glapi_table_func_names being sorted by the + * entry point index of each function. + */ + for (int func_index = 0; func_index < GLAPI_TABLE_COUNT; ++func_index) { + const char *name = _glapi_table_func_names[func_index]; + void ** procp = &((void **)disp)[func_index]; + + snprintf(symboln, sizeof(symboln), \"%s%s\", symbol_prefix, name); +#ifdef _WIN32 + *procp = GetProcAddress(handle, symboln); +#else + *procp = dlsym(handle, symboln); +#endif + } __glapi_gentable_set_remaining_noop(disp); return disp; } -""" -body_template = """ - if(!disp->%(name)s) { - void ** procp = (void **) &disp->%(name)s; - snprintf(symboln, sizeof(symboln), "%%s%(entry_point)s", symbol_prefix); - *procp = dlsym(handle, symboln); - } +void + _glapi_table_patch(struct _glapi_table *table, const char *name, void *wrapper) +{ + for (int func_index = 0; func_index < GLAPI_TABLE_COUNT; ++func_index) { + if (!strcmp(_glapi_table_func_names[func_index], name)) { + ((void **)table)[func_index] = wrapper; + return; + } + } + fprintf(stderr, "could not patch %s in dispatch table\\n", name); +} + """ + class PrintCode(gl_XML.gl_print_base): - def __init__(self): - gl_XML.gl_print_base.__init__(self) + def __init__(self): + gl_XML.gl_print_base.__init__(self) - self.name = "gl_gen_table.py (from Mesa)" - self.license = license.bsd_license_template % ( \ + self.name = "gl_gentable.py (from Mesa)" + self.license = license.bsd_license_template % ( \ """Copyright (C) 1999-2001 Brian Paul All Rights Reserved. (C) Copyright IBM Corporation 2004, 2005 (C) Copyright Apple Inc 2011""", "BRIAN PAUL, IBM") - return + return - def get_stack_size(self, f): - size = 0 - for p in f.parameterIterator(): - if p.is_padding: - continue + def get_stack_size(self, f): + size = 0 + for p in f.parameterIterator(): + if p.is_padding: + continue - size += p.get_stack_size() + size += p.get_stack_size() - return size + return size - def printRealHeader(self): - print header - return + def printRealHeader(self): + print(header) + return - def printRealFooter(self): - print footer - return + def printRealFooter(self): + print(footer) + return - def printBody(self, api): - for f in api.functionIterateByOffset(): - for entry_point in f.entry_points: - vars = { 'entry_point' : entry_point, - 'name' : f.name } + def printBody(self, api): - print body_template % vars - return + # Determine how many functions have a defined offset. + func_count = 0 + for f in api.functions_by_name.values(): + if f.offset != -1: + func_count += 1 -def show_usage(): - print "Usage: %s [-f input_file_name]" % sys.argv[0] - sys.exit(1) + # Build the mapping from offset to function name. + funcnames = [None] * func_count + for f in api.functions_by_name.values(): + if f.offset != -1: + if not (funcnames[f.offset] is None): + raise Exception("Function table has more than one function with same offset (offset %d, func %s)" % (f.offset, f.name)) + funcnames[f.offset] = f.name -if __name__ == '__main__': - file_name = "gl_API.xml" + # Check that the table has no gaps. We expect a function at every offset, + # and the code which generates the table relies on this. + for i in range(0, func_count): + if funcnames[i] is None: + raise Exception("Function table has no function at offset %d" % (i)) - try: - (args, trail) = getopt.getopt(sys.argv[1:], "m:f:") - except Exception,e: - show_usage() + print("#define GLAPI_TABLE_COUNT %d" % func_count) + print("static const char * const _glapi_table_func_names[GLAPI_TABLE_COUNT] = {") + for i in range(0, func_count): + print(" /* %5d */ \"%s\"," % (i, funcnames[i])) + print("};") - for (arg,val) in args: - if arg == "-f": - file_name = val + return - printer = PrintCode() - api = gl_XML.parse_GL_API(file_name, glX_XML.glx_item_factory()) - printer.Print(api) +def _parser(): + """Parse arguments and return a namespace object.""" + parser = argparse.ArgumentParser() + parser.add_argument('-f', + dest='filename', + default='gl_API.xml', + help='An XML file description of an API') + + return parser.parse_args() + + +def main(): + """Main function.""" + args = _parser() + + printer = PrintCode() + + api = gl_XML.parse_GL_API(args.filename, glX_XML.glx_item_factory()) + printer.Print(api) + + +if __name__ == '__main__': + main()