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 function_pointer_type(self, function):
 303         return 'P' + function.name
 304
 305     def function_pointer_value(self, function):
 306         return 'p' + function.name
 307
 308     def trace_function_decl(self, function):
 309         ptype = self.function_pointer_type(function)
 310         pvalue = self.function_pointer_value(function)
 311         print 'typedef ' + function.prototype('* %s' % ptype) + ';'
 312         print 'static %s %s = NULL;' % (ptype, pvalue)
 313         print
 314
 315     def trace_function_fail(self, function):
 316         if function.fail is not None:
 317             if function.type is stdapi.Void:
 318                 assert function.fail == ''
 319                 print '            return;'
 320             else:
 321                 assert function.fail != ''
 322                 print '            return %s;' % function.fail
 323         else:
 324             print '            Trace::Abort();'
 325
 326     def get_function_address(self, function):
 327         raise NotImplementedError
 328
 329     def _get_true_pointer(self, function):
 330         ptype = self.function_pointer_type(function)
 331         pvalue = self.function_pointer_value(function)
 332         print '    if(!%s) {' % (pvalue,)
 333         print '        %s = (%s)%s;' % (pvalue, ptype, self.get_function_address(function))
 334         print '        if(!%s)' % (pvalue,)
 335         self.trace_function_fail(function)
 336         print '    }'
 337
 338     def trace_function_impl(self, function):
 339         pvalue = self.function_pointer_value(function)
 340         print 'extern "C" ' + function.prototype() + ' {'
 341         if function.args:
 342             print '    static const char * __args[%u] = {%s};' % (len(function.args), ', '.join(['"%s"' % arg.name for arg in function.args]))
 343         else:
 344             print '    static const char ** __args = NULL;'
 345         print '    static const Trace::FunctionSig __sig = {%u, "%s", %u, __args};' % (int(function.id), function.name, len(function.args))
 346         if function.type is stdapi.Void:
 347             result = ''
 348         else:
 349             print '    %s __result;' % function.type
 350             result = '__result = '
 351         self._get_true_pointer(function)
 352         print '    unsigned __call = Trace::BeginEnter(__sig);'
 353         for arg in function.args:
 354             if not arg.output:
 355                 self.unwrap_arg(function, arg)
 356                 self.dump_arg(function, arg)
 357         print '    Trace::EndEnter();'
 358         print '    %s%s(%s);' % (result, pvalue, ', '.join([str(arg.name) for arg in function.args]))
 359         print '    Trace::BeginLeave(__call);'
 360         for arg in function.args:
 361             if arg.output:
 362                 self.dump_arg(function, arg)
 363                 self.wrap_arg(function, arg)
 364         if function.type is not stdapi.Void:
 365             self.dump_ret(function, "__result")
 366         print '    Trace::EndLeave();'
 367         if function.type is not stdapi.Void:
 368             self.wrap_ret(function, "__result")
 369             print '    return __result;'
 370         print '}'
 371         print
 372
 373     def dump_arg(self, function, arg):
 374         print '    Trace::BeginArg(%u);' % (arg.index,)
 375         dump_instance(arg.type, arg.name)
 376         print '    Trace::EndArg();'
 377
 378     def wrap_arg(self, function, arg):
 379         wrap_instance(arg.type, arg.name)
 380
 381     def unwrap_arg(self, function, arg):
 382         unwrap_instance(arg.type, arg.name)
 383
 384     def dump_ret(self, function, instance):
 385         print '    Trace::BeginReturn();'
 386         dump_instance(function.type, instance)
 387         print '    Trace::EndReturn();'
 388
 389     def wrap_ret(self, function, instance):
 390         wrap_instance(function.type, instance)
 391
 392     def unwrap_ret(self, function, instance):
 393         unwrap_instance(function.type, instance)
 394
 395     def interface_wrap_impl(self, interface):
 396         print '%s::%s(%s * pInstance) {' % (interface_wrap_name(interface), interface_wrap_name(interface), interface.name)
 397         print '    m_pInstance = pInstance;'
 398         print '}'
 399         print
 400         print '%s::~%s() {' % (interface_wrap_name(interface), interface_wrap_name(interface))
 401         print '}'
 402         print
 403         for method in interface.itermethods():
 404             self.trace_method(interface, method)
 405         print
 406
 407     def trace_method(self, interface, method):
 408         print method.prototype(interface_wrap_name(interface) + '::' + method.name) + ' {'
 409         print '    static const char * __args[%u] = {%s};' % (len(method.args) + 1, ', '.join(['"this"'] + ['"%s"' % arg.name for arg in method.args]))
 410         print '    static const Trace::FunctionSig __sig = {%u, "%s", %u, __args};' % (int(method.id), interface.name + '::' + method.name, len(method.args) + 1)
 411         print '    unsigned __call = Trace::BeginEnter(__sig);'
 412         print '    Trace::BeginArg(0);'
 413         print '    Trace::LiteralOpaque((const void *)m_pInstance);'
 414         print '    Trace::EndArg();'
 415         for arg in method.args:
 416             if not arg.output:
 417                 self.unwrap_arg(method, arg)
 418                 self.dump_arg(method, arg)
 419         if method.type is stdapi.Void:
 420             result = ''
 421         else:
 422             print '    %s __result;' % method.type
 423             result = '__result = '
 424         print '    Trace::EndEnter();'
 425         print '    %sm_pInstance->%s(%s);' % (result, method.name, ', '.join([str(arg.name) for arg in method.args]))
 426         print '    Trace::BeginLeave(__call);'
 427         for arg in method.args:
 428             if arg.output:
 429                 self.dump_arg(method, arg)
 430                 self.wrap_arg(method, arg)
 431         if method.type is not stdapi.Void:
 432             print '    Trace::BeginReturn();'
 433             dump_instance(method.type, "__result")
 434             print '    Trace::EndReturn();'
 435             wrap_instance(method.type, '__result')
 436         print '    Trace::EndLeave();'
 437         if method.name == 'QueryInterface':
 438             print '    if (*ppvObj == m_pInstance)'
 439             print '        *ppvObj = this;'
 440         if method.name == 'Release':
 441             assert method.type is not stdapi.Void
 442             print '    if (!__result)'
 443             print '        delete this;'
 444         if method.type is not stdapi.Void:
 445             print '    return __result;'
 446         print '}'
 447         print
 448
 449
 450 class DllTracer(Tracer):
 451
 452     def __init__(self, dllname):
 453         self.dllname = dllname
 454
 455     def get_function_address(self, function):
 456         return '__GetProcAddress("%s")' % (function.name,)
 457
 458
 459     def header(self, api):
 460         Tracer.header(self, api)
 461
 462         print '''
 463 static HINSTANCE g_hDll = NULL;
 464
 465 static PROC
 466 __GetProcAddress(LPCSTR lpProcName)
 467 {
 468     if (!g_hDll) {
 469         char szDll[MAX_PATH] = {0};
 470
 471         if (!GetSystemDirectoryA(szDll, MAX_PATH)) {
 472             return NULL;
 473         }
 474
 475         strcat(szDll, "\\\\%s");
 476
 477         g_hDll = LoadLibraryA(szDll);
 478         if (!g_hDll) {
 479             return NULL;
 480         }
 481     }
 482
 483     return GetProcAddress(g_hDll, lpProcName);
 484 }
 485
 486     ''' % self.dllname
 487