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     arrays = [
  85         ("Vertex", "VERTEX"),
  86         ("Normal", "NORMAL"),
  87         ("Color", "COLOR"),
  88         ("Index", "INDEX"),
  89         ("TexCoord", "TEXTURE_COORD"),
  90         ("EdgeFlag", "EDGE_FLAG"),
  91         ("FogCoord", "FOG_COORD"),
  92         ("SecondaryColor", "SECONDARY_COLOR"),
  93     ]
  94     arrays.reverse()
  95
  96     def header(self, api):
  97         Tracer.header(self, api)
  98
  99         print '// Whether user arrays were used'
 100         print 'static bool __user_arrays = false;'
 101         print
 102         # Whether we need user arrays
 103         print 'static inline bool __need_user_arrays(void)'
 104         print '{'
 105         print '    if (!__user_arrays) {'
 106         print '        return false;'
 107         print '    }'
 108         print
 109
 110         for camelcase_name, uppercase_name in self.arrays:
 111             function_name = 'gl%sPointer' % camelcase_name
 112             enable_name = 'GL_%s_ARRAY' % uppercase_name
 113             binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
 114             print '    // %s' % function_name
 115             self.array_prolog(api, uppercase_name)
 116             print '    if (__glIsEnabled(%s)) {' % enable_name
 117             print '        GLint __binding = 0;'
 118             print '        __glGetIntegerv(%s, &__binding);' % binding_name
 119             print '        if (!__binding) {'
 120             self.array_cleanup(api, uppercase_name)
 121             print '            return true;'
 122             print '        }'
 123             print '    }'
 124             self.array_epilog(api, uppercase_name)
 125             print
 126
 127         print '    // glVertexAttribPointer'
 128         print '    GLint __max_vertex_attribs = 0;'
 129         print '    __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
 130         print '    for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
 131         print '        GLint __enabled = 0;'
 132         print '        __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &__enabled);'
 133         print '        if (__enabled) {'
 134         print '            GLint __binding = 0;'
 135         print '            __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &__binding);'
 136         print '            if (!__binding) {'
 137         print '                return true;'
 138         print '            }'
 139         print '        }'
 140         print '    }'
 141         print
 142
 143         print '    return false;'
 144         print '}'
 145         print
 146
 147         print 'static void __trace_user_arrays(GLuint maxindex);'
 148         print
 149
 150         print 'struct buffer_mapping {'
 151         print '    void *map;'
 152         print '    GLint length;'
 153         print '    bool write;'
 154         print '};'
 155         print
 156         for target in self.buffer_targets:
 157             print 'struct buffer_mapping __%s_mapping;' % target.lower();
 158         print
 159         print 'static inline struct buffer_mapping *'
 160         print 'get_buffer_mapping(GLenum target) {'
 161         print '    switch(target) {'
 162         for target in self.buffer_targets:
 163             print '    case GL_%s:' % target
 164             print '        return & __%s_mapping;' % target.lower()
 165         print '    default:'
 166         print '        OS::DebugMessage("warning: unknown buffer target 0x%04X\\n", target);'
 167         print '        return NULL;'
 168         print '    }'
 169         print '}'
 170         print
 171
 172         # Generate memcpy's signature
 173         self.trace_function_decl(glapi.memcpy)
 174
 175         # Generate a helper function to determine whether a parameter name
 176         # refers to a symbolic value or not
 177         print 'static bool'
 178         print 'is_symbolic_pname(GLenum pname) {'
 179         print '    switch(pname) {'
 180         for function, type, count, name in glstate.parameters:
 181             if type is glapi.GLenum:
 182                 print '    case %s:' % name
 183         print '        return true;'
 184         print '    default:'
 185         print '        return false;'
 186         print '    }'
 187         print '}'
 188         print
 189
 190         # Generate a helper function to determine whether a parameter value is
 191         # potentially symbolic or not; i.e., if the value can be represented in
 192         # an enum or not
 193         print 'template<class T>'
 194         print 'static inline bool'
 195         print 'is_symbolic_param(T param) {'
 196         print '    return static_cast<T>(static_cast<GLenum>(param)) == param;'
 197         print '}'
 198         print
 199
 200         # Generate a helper function to know how many elements a parameter has
 201         print 'static size_t'
 202         print 'pname_size(GLenum pname) {'
 203         print '    switch(pname) {'
 204         for function, type, count, name in glstate.parameters:
 205             if type is not None:
 206                 print '    case %s: return %u;' % (name, count)
 207         print '    case GL_COMPRESSED_TEXTURE_FORMATS: {'
 208         print '            GLint num_compressed_texture_formats = 0;'
 209         print '            __glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &num_compressed_texture_formats);'
 210         print '            return num_compressed_texture_formats;'
 211         print '        }'
 212         print '    default:'
 213         print r'        OS::DebugMessage("warning: %s: unknown GLenum 0x%04X\n", __FUNCTION__, pname);'
 214         print '        return 1;'
 215         print '    }'
 216         print '}'
 217         print
 218
 219
 220     array_pointer_function_names = set((
 221         "glVertexPointer",
 222         "glNormalPointer",
 223         "glColorPointer",
 224         "glIndexPointer",
 225         "glTexCoordPointer",
 226         "glEdgeFlagPointer",
 227         "glFogCoordPointer",
 228         "glSecondaryColorPointer",
 229
 230         #"glVertexPointerEXT",
 231         #"glNormalPointerEXT",
 232         #"glColorPointerEXT",
 233         #"glIndexPointerEXT",
 234         #"glTexCoordPointerEXT",
 235         #"glEdgeFlagPointerEXT",
 236         #"glFogCoordPointerEXT",
 237         #"glSecondaryColorPointerEXT",
 238
 239         "glVertexAttribPointer",
 240         "glVertexAttribPointerARB",
 241         "glVertexAttribPointerNV",
 242         "glVertexAttribLPointer",
 243         "glVertexAttribLPointerEXT",
 244
 245         #"glMatrixIndexPointerARB",
 246     ))
 247
 248     draw_function_names = set((
 249         'glDrawArrays',
 250         'glDrawElements',
 251         'glDrawRangeElements',
 252     ))
 253
 254     interleaved_formats = [
 255          'GL_V2F',
 256          'GL_V3F',
 257          'GL_C4UB_V2F',
 258          'GL_C4UB_V3F',
 259          'GL_C3F_V3F',
 260          'GL_N3F_V3F',
 261          'GL_C4F_N3F_V3F',
 262          'GL_T2F_V3F',
 263          'GL_T4F_V4F',
 264          'GL_T2F_C4UB_V3F',
 265          'GL_T2F_C3F_V3F',
 266          'GL_T2F_N3F_V3F',
 267          'GL_T2F_C4F_N3F_V3F',
 268          'GL_T4F_C4F_N3F_V4F',
 269     ]
 270
 271     def trace_function_impl_body(self, function):
 272         # Defer tracing of user array pointers...
 273         if function.name in self.array_pointer_function_names:
 274             print '    GLint __array_buffer = 0;'
 275             print '    __glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
 276             print '    if (!__array_buffer) {'
 277             print '        __user_arrays = true;'
 278             self.dispatch_function(function)
 279             print '        return;'
 280             print '    }'
 281
 282         # ... to the draw calls
 283         if function.name in self.draw_function_names:
 284             print '    if (__need_user_arrays()) {'
 285             arg_names = ', '.join([arg.name for arg in function.args[1:]])
 286             print '        GLuint maxindex = __%s_maxindex(%s);' % (function.name, arg_names)
 287             print '        __trace_user_arrays(maxindex);'
 288             print '    }'
 289
 290         # And also break down glInterleavedArrays into the individual calls
 291         if function.name == 'glInterleavedArrays':
 292             print '    GLint __array_buffer = 0;'
 293             print '    __glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
 294             print '    if (!__array_buffer) {'
 295             print '        __user_arrays = true;'
 296             self.dispatch_function(function)
 297             print
 298
 299             # Initialize the enable flags
 300             for camelcase_name, uppercase_name in self.arrays:
 301                 flag_name = '__' + uppercase_name.lower()
 302                 print '        GLboolean %s = GL_FALSE;' % flag_name
 303             print
 304
 305             # Swicth for the interleaved formats
 306             print '        switch (format) {'
 307             for format in self.interleaved_formats:
 308                 print '            case %s:' % format
 309                 for camelcase_name, uppercase_name in self.arrays:
 310                     flag_name = '__' + uppercase_name.lower()
 311                     if format.find('_' + uppercase_name[0]) >= 0:
 312                         print '                %s = GL_TRUE;' % flag_name
 313                 print '                break;'
 314             print '            default:'
 315             print '               return;'
 316             print '        }'
 317             print
 318
 319             # Emit fake glEnableClientState/glDisableClientState flags
 320             for camelcase_name, uppercase_name in self.arrays:
 321                 flag_name = '__' + uppercase_name.lower()
 322                 enable_name = 'GL_%s_ARRAY' % uppercase_name
 323
 324                 # Emit a fake function
 325                 print '        {'
 326                 print '            static const Trace::FunctionSig &__sig = %s ? __glEnableClientState_sig : __glDisableClientState_sig;' % flag_name
 327                 print '            unsigned __call = Trace::BeginEnter(__sig);'
 328                 print '            Trace::BeginArg(0);'
 329                 dump_instance(glapi.GLenum, enable_name)
 330                 print '            Trace::EndArg();'
 331                 print '            Trace::EndEnter();'
 332                 print '            Trace::BeginLeave(__call);'
 333                 print '            Trace::EndLeave();'
 334                 print '        }'
 335
 336             print '        return;'
 337             print '    }'
 338
 339         # Emit a fake memcpy on
 340         if function.name in ('glUnmapBuffer', 'glUnmapBufferARB'):
 341             print '    struct buffer_mapping *mapping = get_buffer_mapping(target);'
 342             print '    if (mapping && mapping->write) {'
 343             print '        unsigned __call = Trace::BeginEnter(__memcpy_sig);'
 344             print '        Trace::BeginArg(0);'
 345             print '        Trace::LiteralOpaque(mapping->map);'
 346             print '        Trace::EndArg();'
 347             print '        Trace::BeginArg(1);'
 348             print '        Trace::LiteralBlob(mapping->map, mapping->length);'
 349             print '        Trace::EndArg();'
 350             print '        Trace::BeginArg(2);'
 351             print '        Trace::LiteralUInt(mapping->length);'
 352             print '        Trace::EndArg();'
 353             print '        Trace::EndEnter();'
 354             print '        Trace::BeginLeave(__call);'
 355             print '        Trace::EndLeave();'
 356             print '    }'
 357
 358         Tracer.trace_function_impl_body(self, function)
 359
 360     buffer_targets = [
 361         'ARRAY_BUFFER',
 362         'ELEMENT_ARRAY_BUFFER',
 363         'PIXEL_PACK_BUFFER',
 364         'PIXEL_UNPACK_BUFFER',
 365     ]
 366
 367     def wrap_ret(self, function, instance):
 368         Tracer.wrap_ret(self, function, instance)
 369
 370         if function.name in ('glMapBuffer', 'glMapBufferARB'):
 371             print '    struct buffer_mapping *mapping = get_buffer_mapping(target);'
 372             print '    if (mapping) {'
 373             print '        mapping->map = %s;' % (instance)
 374             print '        mapping->length = 0;'
 375             print '        __glGetBufferParameteriv(target, GL_BUFFER_SIZE, &mapping->length);'
 376             print '        mapping->write = (access != GL_READ_ONLY);'
 377             print '    }'
 378
 379         if function.name == 'glMapBufferRange':
 380             print '    struct buffer_mapping *mapping = get_buffer_mapping(target);'
 381             print '    if (mapping) {'
 382             print '        mapping->map = %s;' % (instance)
 383             print '        mapping->length = length;'
 384             print '        mapping->write = access & GL_MAP_WRITE_BIT;'
 385             print '    }'
 386
 387     boolean_names = [
 388         'GL_FALSE',
 389         'GL_TRUE',
 390     ]
 391
 392     def gl_boolean(self, value):
 393         return self.boolean_names[int(bool(value))]
 394
 395     def dump_arg_instance(self, function, arg):
 396         if function.name in self.draw_function_names and arg.name == 'indices':
 397             print '    GLint __element_array_buffer = 0;'
 398             print '    __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);'
 399             print '    if (!__element_array_buffer) {'
 400             print '        Trace::LiteralBlob((const void *)%s, count*__gl_type_size(type));' % (arg.name)
 401             print '    } else {'
 402             print '        Trace::LiteralOpaque((const void *)%s);' % (arg.name)
 403             print '    }'
 404             return
 405
 406         # Several GL state functions take GLenum symbolic names as
 407         # integer/floats; so dump the symbolic name whenever possible
 408         if arg.type in (glapi.GLint, glapi.GLfloat) and arg.name == 'param':
 409             assert arg.index > 0
 410             assert function.args[arg.index - 1].name == 'pname'
 411             assert function.args[arg.index - 1].type == glapi.GLenum
 412             print '    if (is_symbolic_pname(pname) && is_symbolic_param(%s)) {' % arg.name
 413             dump_instance(glapi.GLenum, arg.name)
 414             print '    } else {'
 415             Tracer.dump_arg_instance(self, function, arg)
 416             print '    }'
 417             return
 418
 419         Tracer.dump_arg_instance(self, function, arg)
 420
 421     def footer(self, api):
 422         Tracer.footer(self, api)
 423
 424         # A simple state tracker to track the pointer values
 425         # update the state
 426         print 'static void __trace_user_arrays(GLuint maxindex)'
 427         print '{'
 428
 429         for camelcase_name, uppercase_name in self.arrays:
 430             function_name = 'gl%sPointer' % camelcase_name
 431             enable_name = 'GL_%s_ARRAY' % uppercase_name
 432             binding_name = 'GL_%s_ARRAY_BUFFER_BINDING' % uppercase_name
 433             function = api.get_function_by_name(function_name)
 434
 435             print '    // %s' % function.name
 436             self.array_trace_prolog(api, uppercase_name)
 437             self.array_prolog(api, uppercase_name)
 438             print '    if (__glIsEnabled(%s)) {' % enable_name
 439             print '        GLint __binding = 0;'
 440             print '        __glGetIntegerv(%s, &__binding);' % binding_name
 441             print '        if (!__binding) {'
 442
 443             # Get the arguments via glGet*
 444             for arg in function.args:
 445                 arg_get_enum = 'GL_%s_ARRAY_%s' % (uppercase_name, arg.name.upper())
 446                 arg_get_function, arg_type = TypeGetter().visit(arg.type)
 447                 print '            %s %s = 0;' % (arg_type, arg.name)
 448                 print '            __%s(%s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
 449
 450             arg_names = ', '.join([arg.name for arg in function.args[:-1]])
 451             print '            size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
 452
 453             # Emit a fake function
 454             self.array_trace_intermezzo(api, uppercase_name)
 455             print '            unsigned __call = Trace::BeginEnter(__%s_sig);' % (function.name,)
 456             for arg in function.args:
 457                 assert not arg.output
 458                 print '            Trace::BeginArg(%u);' % (arg.index,)
 459                 if arg.name != 'pointer':
 460                     dump_instance(arg.type, arg.name)
 461                 else:
 462                     print '            Trace::LiteralBlob((const void *)%s, __size);' % (arg.name)
 463                 print '            Trace::EndArg();'
 464
 465             print '            Trace::EndEnter();'
 466             print '            Trace::BeginLeave(__call);'
 467             print '            Trace::EndLeave();'
 468             print '        }'
 469             print '    }'
 470             self.array_epilog(api, uppercase_name)
 471             self.array_trace_epilog(api, uppercase_name)
 472             print
 473
 474         # Samething, but for glVertexAttribPointer
 475         print '    // glVertexAttribPointer'
 476         print '    GLint __max_vertex_attribs = 0;'
 477         print '    __glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &__max_vertex_attribs);'
 478         print '    for (GLint index = 0; index < __max_vertex_attribs; ++index) {'
 479         print '        GLint __enabled = 0;'
 480         print '        __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_ENABLED, &__enabled);'
 481         print '        if (__enabled) {'
 482         print '            GLint __binding = 0;'
 483         print '            __glGetVertexAttribiv(index, GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING, &__binding);'
 484         print '            if (!__binding) {'
 485
 486         function = api.get_function_by_name('glVertexAttribPointer')
 487
 488         # Get the arguments via glGet*
 489         for arg in function.args[1:]:
 490             arg_get_enum = 'GL_VERTEX_ATTRIB_ARRAY_%s' % (arg.name.upper(),)
 491             arg_get_function, arg_type = TypeGetter('glGetVertexAttrib', False).visit(arg.type)
 492             print '                %s %s = 0;' % (arg_type, arg.name)
 493             print '                __%s(index, %s, &%s);' % (arg_get_function, arg_get_enum, arg.name)
 494
 495         arg_names = ', '.join([arg.name for arg in function.args[1:-1]])
 496         print '                size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
 497
 498         # Emit a fake function
 499         print '                unsigned __call = Trace::BeginEnter(__%s_sig);' % (function.name,)
 500         for arg in function.args:
 501             assert not arg.output
 502             print '                Trace::BeginArg(%u);' % (arg.index,)
 503             if arg.name != 'pointer':
 504                 dump_instance(arg.type, arg.name)
 505             else:
 506                 print '                Trace::LiteralBlob((const void *)%s, __size);' % (arg.name)
 507             print '                Trace::EndArg();'
 508
 509         print '                Trace::EndEnter();'
 510         print '                Trace::BeginLeave(__call);'
 511         print '                Trace::EndLeave();'
 512         print '            }'
 513         print '        }'
 514         print '    }'
 515         print
 516
 517         print '}'
 518         print
 519
 520     #
 521     # Hooks for glTexCoordPointer, which is identical to the other array
 522     # pointers except the fact that it is indexed by glClientActiveTexture.
 523     #
 524
 525     def array_prolog(self, api, uppercase_name):
 526         if uppercase_name == 'TEXTURE_COORD':
 527             print '    GLint client_active_texture = 0;'
 528             print '    __glGetIntegerv(GL_CLIENT_ACTIVE_TEXTURE, &client_active_texture);'
 529             print '    GLint max_texture_coords = 0;'
 530             print '    __glGetIntegerv(GL_MAX_TEXTURE_COORDS, &max_texture_coords);'
 531             print '    for (GLint unit = 0; unit < max_texture_coords; ++unit) {'
 532             print '        GLenum texture = GL_TEXTURE0 + unit;'
 533             print '        __glClientActiveTexture(texture);'
 534
 535     def array_trace_prolog(self, api, uppercase_name):
 536         if uppercase_name == 'TEXTURE_COORD':
 537             print '    bool client_active_texture_dirty = false;'
 538
 539     def array_epilog(self, api, uppercase_name):
 540         if uppercase_name == 'TEXTURE_COORD':
 541             print '    }'
 542         self.array_cleanup(api, uppercase_name)
 543
 544     def array_cleanup(self, api, uppercase_name):
 545         if uppercase_name == 'TEXTURE_COORD':
 546             print '    __glClientActiveTexture(client_active_texture);'
 547
 548     def array_trace_intermezzo(self, api, uppercase_name):
 549         if uppercase_name == 'TEXTURE_COORD':
 550             print '    if (texture != client_active_texture || client_active_texture_dirty) {'
 551             print '        client_active_texture_dirty = true;'
 552             self.fake_glClientActiveTexture_call(api, "texture");
 553             print '    }'
 554
 555     def array_trace_epilog(self, api, uppercase_name):
 556         if uppercase_name == 'TEXTURE_COORD':
 557             print '    if (client_active_texture_dirty) {'
 558             self.fake_glClientActiveTexture_call(api, "client_active_texture");
 559             print '    }'
 560
 561     def fake_glClientActiveTexture_call(self, api, texture):
 562         function = api.get_function_by_name('glClientActiveTexture')
 563         self.fake_call(function, [texture])
 564
 565     def fake_call(self, function, args):
 566         print '            unsigned __fake_call = Trace::BeginEnter(__%s_sig);' % (function.name,)
 567         for arg, instance in zip(function.args, args):
 568             assert not arg.output
 569             print '            Trace::BeginArg(%u);' % (arg.index,)
 570             dump_instance(arg.type, instance)
 571             print '            Trace::EndArg();'
 572         print '            Trace::EndEnter();'
 573         print '            Trace::BeginLeave(__fake_call);'
 574         print '            Trace::EndLeave();'
 575
 576
 577
 578
 579
 580
 581
 582
 583
 584
 585