git.cworth.org Git - apitrace/blob - gltrace.py

   1 ##########################################################################
   2 #
   3 # Copyright 2008-2010 VMware, Inc.
   4 # All Rights Reserved.
   5 #
   6 # Permission is hereby granted, free of charge, to any person obtaining a copy
   7 # of this software and associated documentation files (the "Software"), to deal
   8 # in the Software without restriction, including without limitation the rights
   9 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10 # copies of the Software, and to permit persons to whom the Software is
  11 # furnished to do so, subject to the following conditions:
  12 #
  13 # The above copyright notice and this permission notice shall be included in
  14 # all copies or substantial portions of the Software.
  15 #
  16 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19 # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22 # THE SOFTWARE.
  23 #
  24 ##########################################################################/
  25
  26
  27 """GL tracing generator."""
  28
  29
  30 import stdapi
  31 import glapi
  32 import glstate
  33 from glxapi import glxapi
  34 from trace import Tracer, dump_instance
  35
  36
  37 class TypeGetter(stdapi.Visitor):
  38     '''Determine which glGet*v function that matches the specified type.'''
  39
  40     def __init__(self, prefix = 'glGet', long_suffix = True):
  41         self.prefix = prefix
  42         self.long_suffix = long_suffix
  43
  44     def visit_const(self, const):
  45         return self.visit(const.type)
  46
  47     def visit_alias(self, alias):
  48         if alias.expr == 'GLboolean':
  49             if self.long_suffix:
  50                 return self.prefix + 'Booleanv', alias.expr
  51             else:
  52                 return self.prefix + 'iv', 'GLint'
  53         elif alias.expr == 'GLdouble':
  54             if self.long_suffix:
  55                 return self.prefix + 'Doublev', alias.expr
  56             else:
  57                 return self.prefix + 'dv', alias.expr
  58         elif alias.expr == 'GLfloat':
  59             if self.long_suffix:
  60                 return self.prefix + 'Floatv', alias.expr
  61             else:
  62                 return self.prefix + 'fv', alias.expr
  63         elif alias.expr in ('GLint', 'GLuint', 'GLsizei'):
  64             if self.long_suffix:
  65                 return self.prefix + 'Integerv', 'GLint'
  66             else:
  67                 return self.prefix + 'iv', 'GLint'
  68         else:
  69             print alias.expr
  70             assert False
  71
  72     def visit_enum(self, enum):
  73         return self.visit(glapi.GLint)
  74
  75     def visit_bitmask(self, bitmask):
  76         return self.visit(glapi.GLint)
  77
  78     def visit_opaque(self, pointer):
  79         return self.prefix + 'Pointerv', 'GLvoid *'
  80
  81
  82 class GlTracer(Tracer):
  83
  84     def header(self, api):
  85         Tracer.header(self, api)
  86         self.state_tracker_decl(api)
  87
  88     def footer(self, api):
  89         Tracer.footer(self, api)
  90         self.state_tracker_impl(api)
  91
  92     arrays = [
  93         ("Vertex", "VERTEX"),
  94         ("Normal", "NORMAL"),
  95         ("Color", "COLOR"),
  96         ("Index", "INDEX"),
  97         ("TexCoord", "TEXTURE_COORD"),
  98         ("EdgeFlag", "EDGE_FLAG"),
  99         ("FogCoord", "FOG_COORD"),
 100         ("SecondaryColor", "SECONDARY_COLOR"),
 101     ]
 102     arrays.reverse()
 103
 104     def state_tracker_decl(self, api):
 105         print '// Whether user arrays were used'
 106         print 'static bool __user_arrays = false;'
 107         print
 108         # Whether we need user arrays
 109         print 'static inline bool __need_user_arrays(void)'
 110         print '{'
 111         print '    if (!__user_arrays) {'
 112         print '        return false;'
 113         print '    }'
 114         print
 115
 116         for camelcase_name, uppercase_name in self.arrays:
 117             function_name = 'gl%sPointer' % camelcase_name
 118             enable_name = 'GL_%s_ARRAY' % uppercase_name
 119             binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
 120             print '    // %s' % function_name
 121             self.array_prolog(api, uppercase_name)
 122             print '    if (__glIsEnabled(%s)) {' % enable_name
 123             print '        GLint __binding = 0;'
 124             print '        __glGetIntegerv(%s, &__binding);' % binding_name
 125             print '        if (!__binding) {'
 126             self.array_cleanup(api, uppercase_name)
 127             print '            return true;'
 128             print '        }'
 129             print '    }'
 130             self.array_epilog(api, uppercase_name)
 131             print
 132
 133         print '    // glVertexAttribPointer'
 134         print '    GLint __max_vertex_attribs = 0;'
 135         print '    __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
 136         print '    for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
 137         print '        GLint __enabled = 0;'
 138         print '        __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &__enabled);'
 139         print '        if (__enabled) {'
 140         print '            GLint __binding = 0;'
 141         print '            __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &__binding);'
 142         print '            if (!__binding) {'
 143         print '                return true;'
 144         print '            }'
 145         print '        }'
 146         print '    }'
 147         print
 148
 149         print '    return false;'
 150         print '}'
 151         print
 152
 153         print 'static void __trace_user_arrays(GLuint maxindex);'
 154         print
 155
 156         print 'struct buffer_mapping {'
 157         print '    void *map;'
 158         print '    GLint length;'
 159         print '    bool write;'
 160         print '};'
 161         print
 162         for target in self.buffer_targets:
 163             print 'struct buffer_mapping __%s_mapping;' % target.lower();
 164         print
 165         print 'static inline struct buffer_mapping *'
 166         print 'get_buffer_mapping(GLenum target) {'
 167         print '    switch(target) {'
 168         for target in self.buffer_targets:
 169             print '    case GL_%s:' % target
 170             print '        return & __%s_mapping;' % target.lower()
 171         print '    default:'
 172         print '        OS::DebugMessage("warning: unknown buffer target 0x%04X\\n", target);'
 173         print '        return NULL;'
 174         print '    }'
 175         print '}'
 176         print
 177
 178         # Generate memcpy's signature
 179         self.trace_function_decl(glapi.memcpy)
 180
 181         # Generate a helper function to determine whether a parameter name
 182         # refers to a symbolic value or not
 183         print 'static bool'
 184         print 'is_symbolic_pname(GLenum pname) {'
 185         print '    switch(pname) {'
 186         for function, type, count, name in glstate.parameters:
 187             if type is glapi.GLenum:
 188                 print '    case %s: return true;' % name
 189         print '    default: return false;'
 190         print '    }'
 191         print '}'
 192         print
 193
 194         # Generate a helper function to determine whether a parameter value is
 195         # potentially symbolic or not; i.e., if the value can be represented in
 196         # an enum or not
 197         print 'template<class T>'
 198         print 'static inline bool'
 199         print 'is_symbolic_param(T param) {'
 200         print '    return static_cast<T>(static_cast<GLenum>(param)) == param;'
 201         print '}'
 202         print
 203
 204     array_pointer_function_names = set((
 205         "glVertexPointer",
 206         "glNormalPointer",
 207         "glColorPointer",
 208         "glIndexPointer",
 209         "glTexCoordPointer",
 210         "glEdgeFlagPointer",
 211         "glFogCoordPointer",
 212         "glSecondaryColorPointer",
 213
 214         #"glVertexPointerEXT",
 215         #"glNormalPointerEXT",
 216         #"glColorPointerEXT",
 217         #"glIndexPointerEXT",
 218         #"glTexCoordPointerEXT",
 219         #"glEdgeFlagPointerEXT",
 220         #"glFogCoordPointerEXT",
 221         #"glSecondaryColorPointerEXT",
 222
 223         "glVertexAttribPointer",
 224         "glVertexAttribPointerARB",
 225         "glVertexAttribPointerNV",
 226         "glVertexAttribLPointer",
 227         "glVertexAttribLPointerEXT",
 228
 229         #"glMatrixIndexPointerARB",
 230     ))
 231
 232     draw_function_names = set((
 233         'glDrawArrays',
 234         'glDrawElements',
 235         'glDrawRangeElements',
 236     ))
 237
 238     interleaved_formats = [
 239          'GL_V2F',
 240          'GL_V3F',
 241          'GL_C4UB_V2F',
 242          'GL_C4UB_V3F',
 243          'GL_C3F_V3F',
 244          'GL_N3F_V3F',
 245          'GL_C4F_N3F_V3F',
 246          'GL_T2F_V3F',
 247          'GL_T4F_V4F',
 248          'GL_T2F_C4UB_V3F',
 249          'GL_T2F_C3F_V3F',
 250          'GL_T2F_N3F_V3F',
 251          'GL_T2F_C4F_N3F_V3F',
 252          'GL_T4F_C4F_N3F_V4F',
 253     ]
 254
 255     def trace_function_impl_body(self, function):
 256         # Defer tracing of user array pointers...
 257         if function.name in self.array_pointer_function_names:
 258             print '    GLint __array_buffer = 0;'
 259             print '    __glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
 260             print '    if (!__array_buffer) {'
 261             print '        __user_arrays = true;'
 262             self.dispatch_function(function)
 263             print '        return;'
 264             print '    }'
 265
 266         # ... to the draw calls
 267         if function.name in self.draw_function_names:
 268             print '    if (__need_user_arrays()) {'
 269             arg_names = ', '.join([arg.name for arg in function.args[1:]])
 270             print '        GLuint maxindex = __%s_maxindex(%s);' % (function.name, arg_names)
 271             print '        __trace_user_arrays(maxindex);'
 272             print '    }'
 273
 274         # And also break down glInterleavedArrays into the individual calls
 275         if function.name == 'glInterleavedArrays':
 276             print '    GLint __array_buffer = 0;'
 277             print '    __glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
 278             print '    if (!__array_buffer) {'
 279             print '        __user_arrays = true;'
 280             self.dispatch_function(function)
 281             print
 282
 283             # Initialize the enable flags
 284             for camelcase_name, uppercase_name in self.arrays:
 285                 flag_name = '__' + uppercase_name.lower()
 286                 print '        GLboolean %s = GL_FALSE;' % flag_name
 287             print
 288
 289             # Swicth for the interleaved formats
 290             print '        switch (format) {'
 291             for format in self.interleaved_formats:
 292                 print '            case %s:' % format
 293                 for camelcase_name, uppercase_name in self.arrays:
 294                     flag_name = '__' + uppercase_name.lower()
 295                     if format.find('_' + uppercase_name[0]) >= 0:
 296                         print '                %s = GL_TRUE;' % flag_name
 297                 print '                break;'
 298             print '            default:'
 299             print '               return;'
 300             print '        }'
 301             print
 302
 303             # Emit fake glEnableClientState/glDisableClientState flags
 304             for camelcase_name, uppercase_name in self.arrays:
 305                 flag_name = '__' + uppercase_name.lower()
 306                 enable_name = 'GL_%s_ARRAY' % uppercase_name
 307
 308                 # Emit a fake function
 309                 print '        {'
 310                 print '            static const Trace::FunctionSig &__sig = %s ? __glEnableClientState_sig : __glDisableClientState_sig;' % flag_name
 311                 print '            unsigned __call = Trace::BeginEnter(__sig);'
 312                 print '            Trace::BeginArg(0);'
 313                 dump_instance(glapi.GLenum, enable_name)
 314                 print '            Trace::EndArg();'
 315                 print '            Trace::EndEnter();'
 316                 print '            Trace::BeginLeave(__call);'
 317                 print '            Trace::EndLeave();'
 318                 print '        }'
 319
 320             print '        return;'
 321             print '    }'
 322
 323         # Emit a fake memcpy on
 324         if function.name in ('glUnmapBuffer', 'glUnmapBufferARB'):
 325             print '    struct buffer_mapping *mapping = get_buffer_mapping(target);'
 326             print '    if (mapping && mapping->write) {'
 327             print '        unsigned __call = Trace::BeginEnter(__memcpy_sig);'
 328             print '        Trace::BeginArg(0);'
 329             print '        Trace::LiteralOpaque(mapping->map);'
 330             print '        Trace::EndArg();'
 331             print '        Trace::BeginArg(1);'
 332             print '        Trace::LiteralBlob(mapping->map, mapping->length);'
 333             print '        Trace::EndArg();'
 334             print '        Trace::BeginArg(2);'
 335             print '        Trace::LiteralUInt(mapping->length);'
 336             print '        Trace::EndArg();'
 337             print '        Trace::EndEnter();'
 338             print '        Trace::BeginLeave(__call);'
 339             print '        Trace::EndLeave();'
 340             print '    }'
 341
 342         Tracer.trace_function_impl_body(self, function)
 343
 344     buffer_targets = [
 345         'ARRAY_BUFFER',
 346         'ELEMENT_ARRAY_BUFFER',
 347         'PIXEL_PACK_BUFFER',
 348         'PIXEL_UNPACK_BUFFER',
 349     ]
 350
 351     def wrap_ret(self, function, instance):
 352         Tracer.wrap_ret(self, function, instance)
 353
 354         if function.name in ('glMapBuffer', 'glMapBufferARB'):
 355             print '    struct buffer_mapping *mapping = get_buffer_mapping(target);'
 356             print '    if (mapping) {'
 357             print '        mapping->map = %s;' % (instance)
 358             print '        mapping->length = 0;'
 359             print '        __glGetBufferParameteriv(target, GL_BUFFER_SIZE, &mapping->length);'
 360             print '        mapping->write = (access != GL_READ_ONLY);'
 361             print '    }'
 362
 363         if function.name == 'glMapBufferRange':
 364             print '    struct buffer_mapping *mapping = get_buffer_mapping(target);'
 365             print '    if (mapping) {'
 366             print '        mapping->map = %s;' % (instance)
 367             print '        mapping->length = length;'
 368             print '        mapping->write = access & GL_MAP_WRITE_BIT;'
 369             print '    }'
 370
 371     boolean_names = [
 372         'GL_FALSE',
 373         'GL_TRUE',
 374     ]
 375
 376     def gl_boolean(self, value):
 377         return self.boolean_names[int(bool(value))]
 378
 379     def dump_arg_instance(self, function, arg):
 380         if function.name in self.draw_function_names and arg.name == 'indices':
 381             print '    GLint __element_array_buffer = 0;'
 382             print '    __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);'
 383             print '    if (!__element_array_buffer) {'
 384             print '        Trace::LiteralBlob((const void *)%s, count*__gl_type_size(type));' % (arg.name)
 385             print '    } else {'
 386             print '        Trace::LiteralOpaque((const void *)%s);' % (arg.name)
 387             print '    }'
 388             return
 389
 390         # Several GL state functions take GLenum symbolic names as
 391         # integer/floats; so dump the symbolic name whenever possible
 392         if arg.type in (glapi.GLint, glapi.GLfloat) and arg.name == 'param':
 393             assert arg.index > 0
 394             assert function.args[arg.index - 1].name == 'pname'
 395             assert function.args[arg.index - 1].type == glapi.GLenum
 396             print '    if (is_symbolic_pname(pname) && is_symbolic_param(%s)) {' % arg.name
 397             dump_instance(glapi.GLenum, arg.name)
 398             print '    } else {'
 399             Tracer.dump_arg_instance(self, function, arg)
 400             print '    }'
 401             return
 402
 403         Tracer.dump_arg_instance(self, function, arg)
 404
 405     def state_tracker_impl(self, api):
 406         # A simple state tracker to track the pointer values
 407
 408         # update the state
 409         print 'static void __trace_user_arrays(GLuint maxindex)'
 410         print '{'
 411
 412         for camelcase_name, uppercase_name in self.arrays:
 413             function_name = 'gl%sPointer' % camelcase_name
 414             enable_name = 'GL_%s_ARRAY' % uppercase_name
 415             binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
 416             function = api.get_function_by_name(function_name)
 417
 418             print '    // %s' % function.name
 419             self.array_trace_prolog(api, uppercase_name)
 420             self.array_prolog(api, uppercase_name)
 421             print '    if (__glIsEnabled(%s)) {' % enable_name
 422             print '        GLint __binding = 0;'
 423             print '        __glGetIntegerv(%s, &__binding);' % binding_name
 424             print '        if (!__binding) {'
 425
 426             # Get the arguments via glGet*
 427             for arg in function.args:
 428                 arg_get_enum = 'GL_%s_ARRAY_%s' % (uppercase_name, arg.name.upper())
 429                 arg_get_function, arg_type = TypeGetter().visit(arg.type)
 430                 print '            %s %s = 0;' % (arg_type, arg.name)
 431                 print '            __%s(%s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
 432
 433             arg_names = ', '.join([arg.name for arg in function.args[:-1]])
 434             print '            size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
 435
 436             # Emit a fake function
 437             self.array_trace_intermezzo(api, uppercase_name)
 438             print '            unsigned __call = Trace::BeginEnter(__%s_sig);' % (function.name,)
 439             for arg in function.args:
 440                 assert not arg.output
 441                 print '            Trace::BeginArg(%u);' % (arg.index,)
 442                 if arg.name != 'pointer':
 443                     dump_instance(arg.type, arg.name)
 444                 else:
 445                     print '            Trace::LiteralBlob((const void *)%s, __size);' % (arg.name)
 446                 print '            Trace::EndArg();'
 447
 448             print '            Trace::EndEnter();'
 449             print '            Trace::BeginLeave(__call);'
 450             print '            Trace::EndLeave();'
 451             print '        }'
 452             print '    }'
 453             self.array_epilog(api, uppercase_name)
 454             self.array_trace_epilog(api, uppercase_name)
 455             print
 456
 457         # Samething, but for glVertexAttribPointer
 458         print '    // glVertexAttribPointer'
 459         print '    GLint __max_vertex_attribs = 0;'
 460         print '    __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
 461         print '    for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
 462         print '        GLint __enabled = 0;'
 463         print '        __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &__enabled);'
 464         print '        if (__enabled) {'
 465         print '            GLint __binding = 0;'
 466         print '            __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &__binding);'
 467         print '            if (!__binding) {'
 468
 469         function = api.get_function_by_name('glVertexAttribPointer')
 470
 471         # Get the arguments via glGet*
 472         for arg in function.args[1:]:
 473             arg_get_enum = 'GL_VERTEX_ATTRIB_ARRAY_%s' % (arg.name.upper(),)
 474             arg_get_function, arg_type = TypeGetter('glGetVertexAttrib', False).visit(arg.type)
 475             print '                %s %s = 0;' % (arg_type, arg.name)
 476             print '                __%s(index, %s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
 477
 478         arg_names = ', '.join([arg.name for arg in function.args[1:-1]])
 479         print '                size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
 480
 481         # Emit a fake function
 482         print '                unsigned __call = Trace::BeginEnter(__%s_sig);' % (function.name,)
 483         for arg in function.args:
 484             assert not arg.output
 485             print '                Trace::BeginArg(%u);' % (arg.index,)
 486             if arg.name != 'pointer':
 487                 dump_instance(arg.type, arg.name)
 488             else:
 489                 print '                Trace::LiteralBlob((const void *)%s, __size);' % (arg.name)
 490             print '                Trace::EndArg();'
 491
 492         print '                Trace::EndEnter();'
 493         print '                Trace::BeginLeave(__call);'
 494         print '                Trace::EndLeave();'
 495         print '            }'
 496         print '        }'
 497         print '    }'
 498         print
 499
 500         print '}'
 501         print
 502
 503     #
 504     # Hooks for glTexCoordPointer, which is identical to the other array
 505     # pointers except the fact that it is indexed by glClientActiveTexture.
 506     #
 507
 508     def array_prolog(self, api, uppercase_name):
 509         if uppercase_name == 'TEXTURE_COORD':
 510             print '    GLint client_active_texture = 0;'
 511             print '    __glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE, &client_active_texture);'
 512             print '    GLint max_texture_coords = 0;'
 513             print '    __glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);'
 514             print '    for (GLint unit = 0; unit < max_texture_coords; ++unit) {'
 515             print '        GLenum texture = GL_TEXTURE0 + unit;'
 516             print '        __glClientActiveTexture(texture);'
 517
 518     def array_trace_prolog(self, api, uppercase_name):
 519         if uppercase_name == 'TEXTURE_COORD':
 520             print '    bool client_active_texture_dirty = false;'
 521
 522     def array_epilog(self, api, uppercase_name):
 523         if uppercase_name == 'TEXTURE_COORD':
 524             print '    }'
 525         self.array_cleanup(api, uppercase_name)
 526
 527     def array_cleanup(self, api, uppercase_name):
 528         if uppercase_name == 'TEXTURE_COORD':
 529             print '    __glClientActiveTexture(client_active_texture);'
 530
 531     def array_trace_intermezzo(self, api, uppercase_name):
 532         if uppercase_name == 'TEXTURE_COORD':
 533             print '    if (texture != client_active_texture || client_active_texture_dirty) {'
 534             print '        client_active_texture_dirty = true;'
 535             self.fake_glClientActiveTexture_call(api, "texture");
 536             print '    }'
 537
 538     def array_trace_epilog(self, api, uppercase_name):
 539         if uppercase_name == 'TEXTURE_COORD':
 540             print '    if (client_active_texture_dirty) {'
 541             self.fake_glClientActiveTexture_call(api, "client_active_texture");
 542             print '    }'
 543
 544     def fake_glClientActiveTexture_call(self, api, texture):
 545         function = api.get_function_by_name('glClientActiveTexture')
 546         self.fake_call(function, [texture])
 547
 548     def fake_call(self, function, args):
 549         print '            unsigned __fake_call = Trace::BeginEnter(__%s_sig);' % (function.name,)
 550         for arg, instance in zip(function.args, args):
 551             assert not arg.output
 552             print '            Trace::BeginArg(%u);' % (arg.index,)
 553             dump_instance(arg.type, instance)
 554             print '            Trace::EndArg();'
 555         print '            Trace::EndEnter();'
 556         print '            Trace::BeginLeave(__fake_call);'
 557         print '            Trace::EndLeave();'
 558
 559
 560
 561
 562
 563
 564
 565
 566
 567
 568