7a93ef10b64f819ab59ced06cb6d89c04ea3ef0d
3 # (C) Copyright IBM Corporation 2004
6 # Permission is hereby granted, free of charge, to any person obtaining a
7 # copy of this software and associated documentation files (the "Software"),
8 # to deal in the Software without restriction, including without limitation
9 # on the rights to use, copy, modify, merge, publish, distribute, sub
10 # license, and/or sell copies of the Software, and to permit persons to whom
11 # the Software is furnished to do so, subject to the following conditions:
13 # The above copyright notice and this permission notice (including the next
14 # paragraph) shall be included in all copies or substantial portions of the
17 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 # FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
20 # IBM AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
26 # Ian Romanick <idr@us.ibm.com>
28 from xml
.sax
import saxutils
29 from xml
.sax
import make_parser
30 from xml
.sax
.handler
import feature_namespaces
38 class PrintGlxProtoStubs(glX_XML
.GlxProto
):
40 glX_XML
.GlxProto
.__init
__(self
)
41 self
.last_category
= ""
42 self
.license
= license
.bsd_license_template
% ( "(C) Copyright IBM Corporation 2004", "IBM")
43 self
.generic_sizes
= [3, 4, 6, 8, 12, 16, 24, 32]
46 def printRealHeader(self
):
48 print '#include <GL/gl.h>'
49 print '#include "indirect.h"'
50 print '#include "glxclient.h"'
51 print '#include "size.h"'
52 print '#include <GL/glxproto.h>'
54 print '#define __GLX_PAD(n) (((n) + 3) & ~3)'
56 glX_XML
.printFastcall()
57 glX_XML
.printNoinline()
59 print '#if !defined __GNUC__ || __GNUC__ < 3'
60 print '# define __builtin_expect(x, y) x'
63 print '/* If the size and opcode values are known at compile-time, this will, on'
64 print ' * x86 at least, emit them with a single instruction.'
66 print '#define emit_header(dest, op, size) \\'
67 print ' do { union { short s[2]; int i; } temp; \\'
68 print ' temp.s[0] = (size); temp.s[1] = (op); \\'
69 print ' *((int *)(dest)) = temp.i; } while(0)'
71 print """static NOINLINE CARD32
72 read_reply( Display *dpy, size_t size, void * dest, GLboolean reply_is_always_array )
74 xGLXSingleReply reply;
76 (void) _XReply(dpy, (xReply *) & reply, 0, False);
78 if ((reply.length > 0) || reply_is_always_array) {
79 const GLint bytes = (reply_is_always_array)
80 ? (4 * reply.length) : (reply.size * size);
81 const GLint extra = 4 - (bytes & 3);
83 _XRead(dpy, dest, bytes);
85 _XEatData(dpy, extra);
89 (void) memcpy( dest, &(reply.pad3), size);
98 static NOINLINE FASTCALL GLubyte *
99 setup_single_request( __GLXcontext * gc, GLint sop, GLint cmdlen )
102 Display * const dpy = gc->currentDpy;
104 (void) __glXFlushRenderBuffer(gc, gc->pc);
106 GetReqExtra(GLXSingle, cmdlen, req);
107 req->reqType = gc->majorOpcode;
108 req->contextTag = gc->currentContextTag;
110 return (GLubyte *)(req) + sz_xGLXSingleReq;
113 static NOINLINE FASTCALL GLubyte *
114 setup_vendor_request( __GLXcontext * gc, GLint code, GLint vop, GLint cmdlen )
116 xGLXVendorPrivateReq * req;
117 Display * const dpy = gc->currentDpy;
119 (void) __glXFlushRenderBuffer(gc, gc->pc);
121 GetReqExtra(GLXVendorPrivate, cmdlen, req);
122 req->reqType = gc->majorOpcode;
124 req->vendorCode = vop;
125 req->contextTag = gc->currentContextTag;
126 return (GLubyte *)(req) + sz_xGLXVendorPrivateReq;
130 for size
in self
.generic_sizes
:
131 self
.print_generic_function(size
)
134 def printFunction(self
, f
):
135 if f
.fn_offset
< 0 or f
.handcode
or f
.ignore
: return
137 if f
.glx_rop
!= 0 or f
.vectorequiv
!= None:
138 self
.printRenderFunction(f
)
139 elif f
.glx_sop
!= 0 or f
.glx_vendorpriv
!= 0:
140 self
.printSingleFunction(f
)
142 print "/* Missing GLX protocol for %s. */" % (f
.name
)
144 def print_generic_function(self
, n
):
146 print """static FASTCALL NOINLINE void
147 generic_%u_byte( GLint rop, const void * ptr )
149 __GLXcontext * const gc = __glXGetCurrentContext();
150 const GLuint cmdlen = %u;
152 emit_header(gc->pc, rop, cmdlen);
153 (void) memcpy((void *)(gc->pc + 4), ptr, %u);
155 if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }
157 """ % (n
, size
+ 4, size
)
160 def common_emit_one_arg(self
, p
, offset
, pc
, indent
, adjust
):
165 src_ptr
= "&" + p
.name
167 print '%s (void) memcpy((void *)(%s + %u), (void *)(%s), %s);' \
168 % (indent
, pc
, offset
+ adjust
, src_ptr
, p
.size_string() )
170 def common_emit_args(self
, f
, pc
, indent
, adjust
, skip_vla
):
178 for p
in f
.parameterIterator(1, r
):
179 self
.common_emit_one_arg(p
, offset
, pc
, indent
, adjust
)
185 def large_emit_begin(self
, indent
, f
):
186 print '%s const GLint op = %s;' % (indent
, f
.opcode_real_name())
187 print '%s const GLuint cmdlenLarge = cmdlen + 4;' % (indent
)
188 print '%s GLubyte * const pc = __glXFlushRenderBuffer(gc, gc->pc);' % (indent
)
189 print '%s (void) memcpy((void *)(pc + 0), (void *)(&cmdlenLarge), 4);' % (indent
)
190 print '%s (void) memcpy((void *)(pc + 4), (void *)(&op), 4);' % (indent
)
194 def common_func_print_just_header(self
, f
):
195 print '#define %s %d' % (f
.opcode_name(), f
.opcode_value())
197 print '%s' % (f
.fn_return_type
)
198 print '__indirect_gl%s(%s)' % (f
.name
, f
.get_parameter_string())
202 def common_func_print_header(self
, f
):
203 self
.common_func_print_just_header(f
)
205 print ' __GLXcontext * const gc = __glXGetCurrentContext();'
207 # The only reason that single and vendor private commands need
208 # a variable called 'dpy' is becuase they use the SyncHandle
209 # macro. For whatever brain-dead reason, that macro is hard-
210 # coded to use a variable called 'dpy' instead of taking a
214 print ' Display * const dpy = gc->currentDpy;'
215 skip_condition
= "dpy != NULL"
217 skip_condition
= "gc->currentDpy != NULL"
219 skip_condition
= None
222 if f
.fn_return_type
!= 'void':
223 print ' %s retval = (%s) 0;' % (f
.fn_return_type
, f
.fn_return_type
)
225 if f
.count_parameters
!= None:
226 print ' const GLuint compsize = __gl%s_size(%s);' % (f
.name
, f
.count_parameters
)
228 print ' const GLuint cmdlen = %s;' % (f
.command_length())
232 skip_condition
= "(%s >= 0) && (%s)" % (f
.counter
, skip_condition
)
234 skip_condition
= "%s >= 0" % (f
.counter
)
238 print ' if (__builtin_expect(%s, 1)) {' % (skip_condition
)
244 def printSingleFunction(self
, f
):
245 self
.common_func_print_header(f
)
247 if f
.fn_parameters
!= []:
248 pc_decl
= "GLubyte const * pc ="
252 if f
.glx_vendorpriv
!= 0:
253 print ' %s setup_vendor_request(gc, %s, %s, cmdlen);' % (pc_decl
, f
.opcode_real_name(), f
.opcode_name())
255 print ' %s setup_single_request(gc, %s, cmdlen);' % (pc_decl
, f
.opcode_name())
257 self
.common_emit_args(f
, "pc", " ", 0, 0)
261 output_size
= f
.output
.p_type
.size
262 output_str
= f
.output
.name
267 if f
.fn_return_type
!= 'void':
268 return_str
= " retval = (%s)" % (f
.fn_return_type
)
270 return_str
= " (void)"
272 if f
.reply_always_array
:
277 print " %s read_reply(dpy, %s, %s, %s);" % (return_str
, output_size
, output_str
, aa
)
279 print ' UnlockDisplay(dpy); SyncHandle();'
281 print ' %s' % f
.return_string()
287 def printRenderFunction(self
, f
):
288 # There is a class of GL functions that take a single pointer
289 # as a parameter. This pointer points to a fixed-size chunk
290 # of data, and the protocol for this functions is very
291 # regular. Since they are so regular and there are so many
292 # of them, special case them with generic functions. On
293 # x86, this saves about 26KB in the libGL.so binary.
295 if f
.variable_length_parameter() == None and len(f
.fn_parameters
) == 1:
296 p
= f
.fn_parameters
[0]
298 [cmdlen
, size_string
] = f
.command_payload_length()
299 if cmdlen
in self
.generic_sizes
:
300 self
.common_func_print_just_header(f
)
301 print ' generic_%u_byte( %s, %s );' % (cmdlen
, f
.opcode_real_name(), p
.name
)
306 if self
.common_func_print_header(f
):
314 print '%s if (cmdlen <= gc->maxSmallRenderCommandSize) {' % (indent
)
315 print '%s if ( (gc->pc + cmdlen) > gc->bufEnd ) {' % (indent
)
316 print '%s (void) __glXFlushRenderBuffer(gc, gc->pc);' % (indent
)
317 print '%s }' % (indent
)
320 print '%s emit_header(gc->pc, %s, cmdlen);' % (indent
, f
.opcode_real_name())
322 self
.common_emit_args(f
, "gc->pc", indent
, 4, 0)
323 print '%s gc->pc += cmdlen;' % (indent
)
324 print '%s if (__builtin_expect(gc->pc > gc->limit, 0)) { (void) __glXFlushRenderBuffer(gc, gc->pc); }' % (indent
)
327 print '%s}' % (indent
)
328 print '%selse {' % (indent
)
330 self
.large_emit_begin(indent
, f
)
331 offset
= self
.common_emit_args(f
, "pc", indent
, 8, 1)
333 p
= f
.variable_length_parameter()
334 print '%s __glXSendLargeCommand(gc, pc, %u, %s, %s);' % (indent
, offset
+ 8, p
.name
, p
.size_string())
335 print '%s}' % (indent
)
337 if trailer
: print trailer
343 class PrintGlxProtoInit_c(glX_XML
.GlxProto
):
345 glX_XML
.GlxProto
.__init
__(self
)
346 self
.last_category
= ""
347 self
.license
= license
.bsd_license_template
% ( \
348 """Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
349 (C) Copyright IBM Corporation 2004""", "PRECISION INSIGHT, IBM")
352 def printRealHeader(self
):
354 * \\file indirect_init.c
355 * Initialize indirect rendering dispatch table.
357 * \\author Kevin E. Martin <kevin@precisioninsight.com>
358 * \\author Brian Paul <brian@precisioninsight.com>
359 * \\author Ian Romanick <idr@us.ibm.com>
362 #include "indirect_init.h"
363 #include "indirect.h"
368 * No-op function used to initialize functions that have no GLX protocol
371 static int NoOp(void)
377 * Create and initialize a new GL dispatch table. The table is initialized
378 * with GLX indirect rendering protocol functions.
380 __GLapi * __glXNewIndirectAPI( void )
385 entries = _glapi_get_dispatch_table_size();
386 glAPI = (__GLapi *) Xmalloc(entries * sizeof(void *));
388 /* first, set all entries to point to no-op functions */
391 void **dispatch = (void **) glAPI;
392 for (i = 0; i < entries; i++) {
393 dispatch[i] = (void *) NoOp;
397 /* now, initialize the entries we understand */"""
399 def printRealFooter(self
):
405 def printFunction(self
, f
):
406 if f
.fn_offset
< 0 or f
.ignore
: return
408 if f
.category
!= self
.last_category
:
409 self
.last_category
= f
.category
411 print ' /* %s */' % (self
.last_category
)
414 print ' glAPI->%s = __indirect_gl%s;' % (f
.name
, f
.name
)
417 class PrintGlxProtoInit_h(glX_XML
.GlxProto
):
419 glX_XML
.GlxProto
.__init
__(self
)
420 self
.last_category
= ""
421 self
.license
= license
.bsd_license_template
% ( \
422 """Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
423 (C) Copyright IBM Corporation 2004""", "PRECISION INSIGHT, IBM")
426 def printRealHeader(self
):
430 * Prototypes for indirect rendering functions.
432 * \\author Kevin E. Martin <kevin@precisioninsight.com>
433 * \\author Ian Romanick <idr@us.ibm.com>
436 #if !defined( _INDIRECT_H_ )
437 # define _INDIRECT_H_
440 glX_XML
.printVisibility( "HIDDEN", "hidden" )
443 def printRealFooter(self
):
444 print "# undef HIDDEN"
445 print "#endif /* !defined( _INDIRECT_H_ ) */"
447 def printFunction(self
, f
):
448 if f
.fn_offset
< 0 or f
.ignore
: return
449 print 'extern HIDDEN %s __indirect_gl%s(%s);' % (f
.fn_return_type
, f
.name
, f
.get_parameter_string())
452 class PrintGlxSizeStubs(glX_XML
.GlxProto
):
454 glX_XML
.GlxProto
.__init
__(self
)
455 self
.license
= license
.bsd_license_template
% ( "(C) Copyright IBM Corporation 2004", "IBM")
457 self
.glx_enum_sigs
= {}
459 def printRealHeader(self
):
461 print '#include <GL/gl.h>'
462 print '#include "indirect_size.h"'
467 glX_XML
.printFastcall()
469 glX_XML
.printVisibility( "INTERNAL", "internal" )
472 print '#ifdef HAVE_ALIAS'
473 print '# define ALIAS2(from,to) \\'
474 print ' INTERNAL PURE FASTCALL GLint __gl ## from ## _size( GLenum e ) \\'
475 print ' __attribute__ ((alias( # to )));'
476 print '# define ALIAS(from,to) ALIAS2( from, __gl ## to ## _size )'
478 print '# define ALIAS(from,to) \\'
479 print ' INTERNAL PURE FASTCALL GLint __gl ## from ## _size( GLenum e ) \\'
480 print ' { return __gl ## to ## _size( e ); }'
485 def printRealFooter(self
):
486 for a
in self
.aliases
:
489 def printFunction(self
, f
):
490 if self
.glx_enum_functions
.has_key(f
.name
):
491 ef
= self
.glx_enum_functions
[f
.name
]
493 sig
= ef
.signature();
494 if self
.glx_enum_sigs
.has_key(sig
):
495 n
= self
.glx_enum_sigs
[sig
];
496 a
= 'ALIAS( %s, %s )' % (f
.name
, n
)
497 self
.aliases
.append(a
)
500 self
.glx_enum_sigs
[sig
] = f
.name
;
504 class PrintGlxSizeStubs_h(glX_XML
.GlxProto
):
506 glX_XML
.GlxProto
.__init
__(self
)
507 self
.license
= license
.bsd_license_template
% ( "(C) Copyright IBM Corporation 2004", "IBM")
509 self
.glx_enum_sigs
= {}
511 def printRealHeader(self
):
515 * Prototypes for functions used to determine the number of data elements in
516 * various GLX protocol messages.
518 * \\author Ian Romanick <idr@us.ibm.com>
521 #if !defined( _GLXSIZE_H_ )
527 glX_XML
.printFastcall();
529 glX_XML
.printVisibility( "INTERNAL", "internal" );
532 def printRealFooter(self
):
534 print "# undef INTERNAL"
536 print "# undef FASTCALL"
537 print "#endif /* !defined( _GLXSIZE_H_ ) */"
540 def printFunction(self
, f
):
541 if self
.glx_enum_functions
.has_key(f
.name
):
542 ef
= self
.glx_enum_functions
[f
.name
]
543 print 'extern INTERNAL PURE FASTCALL GLint __gl%s_size(GLenum);' % (f
.name
)
547 print "Usage: %s [-f input_file_name] [-m output_mode]" % sys
.argv
[0]
551 if __name__
== '__main__':
552 file_name
= "gl_API.xml"
555 (args
, trail
) = getopt
.getopt(sys
.argv
[1:], "f:m:")
560 for (arg
,val
) in args
:
567 dh
= PrintGlxProtoStubs()
568 elif mode
== "init_c":
569 dh
= PrintGlxProtoInit_c()
570 elif mode
== "init_h":
571 dh
= PrintGlxProtoInit_h()
572 elif mode
== "size_c":
573 dh
= PrintGlxSizeStubs()
574 elif mode
== "size_h":
575 dh
= PrintGlxSizeStubs_h()
579 parser
= make_parser()
580 parser
.setFeature(feature_namespaces
, 0)
581 parser
.setContentHandler(dh
)