git.cworth.org Git - apitrace/blob - trace.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 """Common trace code generation."""
  27
  28
  29 import stdapi
  30
  31
  32 def interface_wrap_name(interface):
  33     return "Wrap" + interface.expr
  34
  35
  36 class DumpDeclarator(stdapi.OnceVisitor):
  37     '''Declare helper functions to dump complex types.'''
  38
  39     def visit_void(self, literal):
  40         pass
  41
  42     def visit_literal(self, literal):
  43         pass
  44
  45     def visit_string(self, string):
  46         pass
  47
  48     def visit_const(self, const):
  49         self.visit(const.type)
  50
  51     def visit_struct(self, struct):
  52         for type, name in struct.members:
  53             self.visit(type)
  54         print 'static void __traceStruct%s(const %s &value) {' % (struct.id, struct.expr)
  55         print '    static const char * members[%u] = {' % (len(struct.members),)
  56         for type, name,  in struct.members:
  57             print '        "%s",' % (name,)
  58         print '    };'
  59         print '    static const Trace::StructSig sig = {'
  60         print '       %u, "%s", %u, members' % (int(struct.id), struct.name, len(struct.members))
  61         print '    };'
  62         print '    Trace::BeginStruct(&sig);'
  63         for type, name in struct.members:
  64             dump_instance(type, 'value.%s' % (name,))
  65         print '    Trace::EndStruct();'
  66         print '}'
  67         print
  68
  69     def visit_array(self, array):
  70         self.visit(array.type)
  71
  72     def visit_blob(self, array):
  73         pass
  74
  75     def visit_enum(self, enum):
  76         print 'static void __traceEnum%s(const %s value) {' % (enum.id, enum.expr)
  77         n = len(enum.values)
  78         for i in range(n):
  79             value = enum.values[i]
  80             print '    static const Trace::EnumSig sig%u = {%u, "%s", %s};' % (i, enum.vid + i, value, value)
  81         print '    const Trace::EnumSig *sig;'
  82         print '    switch(value) {'
  83         for i in range(n):
  84             value = enum.values[i]
  85             print '    case %s:' % value
  86             print '        sig = &sig%u;' % i
  87             print '        break;'
  88         print '    default:'
  89         print '        Trace::LiteralSInt(value);'
  90         print '        return;'
  91         print '    }'
  92         print '        Trace::LiteralEnum(sig);'
  93         print '}'
  94         print
  95
  96     def visit_bitmask(self, bitmask):
  97         print 'static const Trace::BitmaskVal __bitmask%s_vals[] = {' % (bitmask.id)
  98         for value in bitmask.values:
  99             print '   {"%s", %s},' % (value, value)
 100         print '};'
 101         print
 102         print 'static const Trace::BitmaskSig __bitmask%s_sig = {' % (bitmask.id)
 103         print '   %u, %u, __bitmask%s_vals' % (int(bitmask.id), len(bitmask.values), bitmask.id)
 104         print '};'
 105         print
 106
 107     def visit_pointer(self, pointer):
 108         self.visit(pointer.type)
 109
 110     def visit_handle(self, handle):
 111         self.visit(handle.type)
 112
 113     def visit_alias(self, alias):
 114         self.visit(alias.type)
 115
 116     def visit_opaque(self, opaque):
 117         pass
 118
 119     def visit_interface(self, interface):
 120         print "class %s : public %s " % (interface_wrap_name(interface), interface.name)
 121         print "{"
 122         print "public:"
 123         print "    %s(%s * pInstance);" % (interface_wrap_name(interface), interface.name)
 124         print "    virtual ~%s();" % interface_wrap_name(interface)
 125         print
 126         for method in interface.itermethods():
 127             print "    " + method.prototype() + ";"
 128         print
 129         #print "private:"
 130         print "    %s * m_pInstance;" % (interface.name,)
 131         print "};"
 132         print
 133
 134
 135 class DumpImplementer(stdapi.Visitor):
 136     '''Dump an instance.'''
 137
 138     def visit_literal(self, literal, instance):
 139         print '    Trace::Literal%s(%s);' % (literal.format, instance)
 140
 141     def visit_string(self, string, instance):
 142         if string.length is not None:
 143             print '    Trace::LiteralString((const char *)%s, %s);' % (instance, string.length)
 144         else:
 145             print '    Trace::LiteralString((const char *)%s);' % instance
 146
 147     def visit_const(self, const, instance):
 148         self.visit(const.type, instance)
 149
 150     def visit_struct(self, struct, instance):
 151         print '    __traceStruct%s(%s);' % (struct.id, instance)
 152
 153     def visit_array(self, array, instance):
 154         print '    if(%s) {' % instance
 155         index = '__i' + array.type.id
 156         print '        Trace::BeginArray(%s);' % (array.length,)
 157         print '        for (int %s = 0; %s < %s; ++%s) {' % (index, index, array.length, index)
 158         print '            Trace::BeginElement();'
 159         self.visit(array.type, '(%s)[%s]' % (instance, index))
 160         print '            Trace::EndElement();'
 161         print '        }'
 162         print '        Trace::EndArray();'
 163         print '    }'
 164         print '    else'
 165         print '        Trace::LiteralNull();'
 166
 167     def visit_blob(self, blob, instance):
 168         print '    Trace::LiteralBlob(%s, %s);' % (instance, blob.size)
 169
 170     def visit_enum(self, enum, instance):
 171         print '    __traceEnum%s(%s);' % (enum.id, instance)
 172
 173     def visit_bitmask(self, bitmask, instance):
 174         print '    Trace::LiteralBitmask(__bitmask%s_sig, %s);' % (bitmask.id, instance)
 175
 176     def visit_pointer(self, pointer, instance):
 177         print '    if(%s) {' % instance
 178         print '        Trace::BeginArray(1);'
 179         print '        Trace::BeginElement();'
 180         dump_instance(pointer.type, "*" + instance)
 181         print '        Trace::EndElement();'
 182         print '        Trace::EndArray();'
 183         print '    }'
 184         print '    else'
 185         print '        Trace::LiteralNull();'
 186
 187     def visit_handle(self, handle, instance):
 188         self.visit(handle.type, instance)
 189
 190     def visit_alias(self, alias, instance):
 191         self.visit(alias.type, instance)
 192
 193     def visit_opaque(self, opaque, instance):
 194         print '    Trace::LiteralOpaque((const void *)%s);' % instance
 195
 196     def visit_interface(self, interface, instance):
 197         print '    Trace::LiteralOpaque((const void *)&%s);' % instance
 198
 199
 200 dump_instance = DumpImplementer().visit
 201
 202
 203
 204 class Wrapper(stdapi.Visitor):
 205     '''Wrap an instance.'''
 206
 207     def visit_void(self, type, instance):
 208         raise NotImplementedError
 209
 210     def visit_literal(self, type, instance):
 211         pass
 212
 213     def visit_string(self, type, instance):
 214         pass
 215
 216     def visit_const(self, type, instance):
 217         pass
 218
 219     def visit_struct(self, struct, instance):
 220         for type, name in struct.members:
 221             self.visit(type, "(%s).%s" % (instance, name))
 222
 223     def visit_array(self, array, instance):
 224         # XXX: actually it is possible to return an array of pointers
 225         pass
 226
 227     def visit_blob(self, blob, instance):
 228         pass
 229
 230     def visit_enum(self, enum, instance):
 231         pass
 232
 233     def visit_bitmask(self, bitmask, instance):
 234         pass
 235
 236     def visit_pointer(self, pointer, instance):
 237         self.visit(pointer.type, "*" + instance)
 238
 239     def visit_handle(self, handle, instance):
 240         self.visit(handle.type, instance)
 241
 242     def visit_alias(self, alias, instance):
 243         self.visit(alias.type, instance)
 244
 245     def visit_opaque(self, opaque, instance):
 246         pass
 247
 248     def visit_interface(self, interface, instance):
 249         assert instance.startswith('*')
 250         instance = instance[1:]
 251         print "    if(%s)" % instance
 252         print "        %s = new %s(%s);" % (instance, interface_wrap_name(interface), instance)
 253
 254
 255 class Unwrapper(Wrapper):
 256
 257     def visit_interface(self, interface, instance):
 258         assert instance.startswith('*')
 259         instance = instance[1:]
 260         print "    if(%s)" % instance
 261         print "        %s = static_cast<%s *>(%s)->m_pInstance;" % (instance, interface_wrap_name(interface), instance)
 262
 263
 264 wrap_instance = Wrapper().visit
 265 unwrap_instance = Unwrapper().visit
 266
 267
 268 class Tracer:
 269
 270     def trace_api(self, api):
 271         self.header(api)
 272
 273         # Includes
 274         for header in api.headers:
 275             print header
 276         print
 277
 278         # Type dumpers
 279         types = api.all_types()
 280         visitor = DumpDeclarator()
 281         map(visitor.visit, types)
 282         print
 283
 284         # Interfaces wrapers
 285         interfaces = [type for type in types if isinstance(type, stdapi.Interface)]
 286         map(self.interface_wrap_impl, interfaces)
 287         print
 288
 289         # Function wrappers
 290         map(self.trace_function_decl, api.functions)
 291         map(self.trace_function_impl, api.functions)
 292         print
 293
 294         self.footer(api)
 295
 296     def header(self, api):
 297         pass
 298
 299     def footer(self, api):
 300         pass
 301
 302     def trace_function_decl(self, function):
 303         # Per-function declarations
 304
 305         if function.args:
 306             print 'static const char * __%s_args[%u] = {%s};' % (function.name, len(function.args), ', '.join(['"%s"' % arg.name for arg in function.args]))
 307         else:
 308             print 'static const char ** __%s_args = NULL;' % (function.name,)
 309         print 'static const Trace::FunctionSig __%s_sig = {%u, "%s", %u, __%s_args};' % (function.name, int(function.id), function.name, len(function.args), function.name)
 310         print
 311
 312     def get_dispatch_function(self, function):
 313         return '__' + function.name
 314
 315     def trace_function_impl(self, function):
 316         print 'extern "C" ' + function.prototype() + ' {'
 317         if function.type is not stdapi.Void:
 318             print '    %s __result;' % function.type
 319         self.trace_function_impl_body(function)
 320         if function.type is not stdapi.Void:
 321             self.wrap_ret(function, "__result")
 322             print '    return __result;'
 323         print '}'
 324         print
 325
 326     def trace_function_impl_body(self, function):
 327         print '    unsigned __call = Trace::BeginEnter(__%s_sig);' % (function.name,)
 328         for arg in function.args:
 329             if not arg.output:
 330                 self.unwrap_arg(function, arg)
 331                 self.dump_arg(function, arg)
 332         print '    Trace::EndEnter();'
 333         self.dispatch_function(function)
 334         print '    Trace::BeginLeave(__call);'
 335         for arg in function.args:
 336             if arg.output:
 337                 self.dump_arg(function, arg)
 338                 self.wrap_arg(function, arg)
 339         if function.type is not stdapi.Void:
 340             self.dump_ret(function, "__result")
 341         print '    Trace::EndLeave();'
 342
 343     def dispatch_function(self, function):
 344         if function.type is stdapi.Void:
 345             result = ''
 346         else:
 347             result = '__result = '
 348         dispatch = self.get_dispatch_function(function)
 349         print '    %s%s(%s);' % (result, dispatch, ', '.join([str(arg.name) for arg in function.args]))
 350
 351     def dump_arg(self, function, arg):
 352         print '    Trace::BeginArg(%u);' % (arg.index,)
 353         dump_instance(arg.type, arg.name)
 354         print '    Trace::EndArg();'
 355
 356     def wrap_arg(self, function, arg):
 357         wrap_instance(arg.type, arg.name)
 358
 359     def unwrap_arg(self, function, arg):
 360         unwrap_instance(arg.type, arg.name)
 361
 362     def dump_ret(self, function, instance):
 363         print '    Trace::BeginReturn();'
 364         dump_instance(function.type, instance)
 365         print '    Trace::EndReturn();'
 366
 367     def wrap_ret(self, function, instance):
 368         wrap_instance(function.type, instance)
 369
 370     def unwrap_ret(self, function, instance):
 371         unwrap_instance(function.type, instance)
 372
 373     def interface_wrap_impl(self, interface):
 374         print '%s::%s(%s * pInstance) {' % (interface_wrap_name(interface), interface_wrap_name(interface), interface.name)
 375         print '    m_pInstance = pInstance;'
 376         print '}'
 377         print
 378         print '%s::~%s() {' % (interface_wrap_name(interface), interface_wrap_name(interface))
 379         print '}'
 380         print
 381         for method in interface.itermethods():
 382             self.trace_method(interface, method)
 383         print
 384
 385     def trace_method(self, interface, method):
 386         print method.prototype(interface_wrap_name(interface) + '::' + method.name) + ' {'
 387         print '    static const char * __args[%u] = {%s};' % (len(method.args) + 1, ', '.join(['"this"'] + ['"%s"' % arg.name for arg in method.args]))
 388         print '    static const Trace::FunctionSig __sig = {%u, "%s", %u, __args};' % (int(method.id), interface.name + '::' + method.name, len(method.args) + 1)
 389         print '    unsigned __call = Trace::BeginEnter(__sig);'
 390         print '    Trace::BeginArg(0);'
 391         print '    Trace::LiteralOpaque((const void *)m_pInstance);'
 392         print '    Trace::EndArg();'
 393         for arg in method.args:
 394             if not arg.output:
 395                 self.unwrap_arg(method, arg)
 396                 self.dump_arg(method, arg)
 397         if method.type is stdapi.Void:
 398             result = ''
 399         else:
 400             print '    %s __result;' % method.type
 401             result = '__result = '
 402         print '    Trace::EndEnter();'
 403         print '    %sm_pInstance->%s(%s);' % (result, method.name, ', '.join([str(arg.name) for arg in method.args]))
 404         print '    Trace::BeginLeave(__call);'
 405         for arg in method.args:
 406             if arg.output:
 407                 self.dump_arg(method, arg)
 408                 self.wrap_arg(method, arg)
 409         if method.type is not stdapi.Void:
 410             print '    Trace::BeginReturn();'
 411             dump_instance(method.type, "__result")
 412             print '    Trace::EndReturn();'
 413             wrap_instance(method.type, '__result')
 414         print '    Trace::EndLeave();'
 415         if method.name == 'QueryInterface':
 416             print '    if (*ppvObj == m_pInstance)'
 417             print '        *ppvObj = this;'
 418         if method.name == 'Release':
 419             assert method.type is not stdapi.Void
 420             print '    if (!__result)'
 421             print '        delete this;'
 422         if method.type is not stdapi.Void:
 423             print '    return __result;'
 424         print '}'
 425         print
 426
 427
 428 class DllTracer(Tracer):
 429
 430     def __init__(self, dllname):
 431         self.dllname = dllname
 432
 433     def get_function_address(self, function):
 434         return '__%s' % (function.name,)
 435
 436     def header(self, api):
 437         Tracer.header(self, api)
 438
 439         print '''
 440 static HINSTANCE g_hDll = NULL;
 441
 442 static PROC
 443 __GetProcAddress(LPCSTR lpProcName)
 444 {
 445     if (!g_hDll) {
 446         char szDll[MAX_PATH] = {0};
 447
 448         if (!GetSystemDirectoryA(szDll, MAX_PATH)) {
 449             return NULL;
 450         }
 451
 452         strcat(szDll, "\\\\%s");
 453
 454         g_hDll = LoadLibraryA(szDll);
 455         if (!g_hDll) {
 456             return NULL;
 457         }
 458     }
 459
 460     return GetProcAddress(g_hDll, lpProcName);
 461 }
 462
 463     ''' % self.dllname
 464