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

   1 ##########################################################################
   2 #
   3 # Copyright 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 """Generic retracing code generator."""
  28
  29 import stdapi
  30 import glapi
  31 from codegen import *
  32
  33
  34 class ConstRemover(stdapi.Rebuilder):
  35
  36     def visit_const(self, const):
  37         return const.type
  38
  39     def visit_opaque(self, opaque):
  40         return opaque
  41
  42
  43 def handle_entry(handle, value):
  44     if handle.key is None:
  45         return "__%s_map[%s]" % (handle.name, value)
  46     else:
  47         key_name, key_type = handle.key
  48         return "__%s_map[%s][%s]" % (handle.name, key_name, value)
  49
  50
  51 class ValueExtractor(stdapi.Visitor):
  52
  53     def visit_literal(self, literal, lvalue, rvalue):
  54         #if literal.format in ('Bool', 'UInt'):
  55         print '    %s = (%s).to%s();' % (lvalue, rvalue, literal.format)
  56
  57     def visit_const(self, const, lvalue, rvalue):
  58         self.visit(const.type, lvalue, rvalue)
  59
  60     def visit_alias(self, alias, lvalue, rvalue):
  61         self.visit(alias.type, lvalue, rvalue)
  62
  63     def visit_enum(self, enum, lvalue, rvalue):
  64         print '    %s = (%s).toSInt();' % (lvalue, rvalue)
  65
  66     def visit_bitmask(self, bitmask, lvalue, rvalue):
  67         self.visit(bitmask.type, lvalue, rvalue)
  68
  69     def visit_array(self, array, lvalue, rvalue):
  70         print '    const Trace::Array *__a%s = dynamic_cast<const Trace::Array *>(&%s);' % (array.id, rvalue)
  71         print '    if (__a%s) {' % (array.id)
  72         length = '__a%s->values.size()' % array.id
  73         print '        %s = new %s[%s];' % (lvalue, array.type, length)
  74         index = '__j' + array.id
  75         print '        for (size_t {i} = 0; {i} < {length}; ++{i}) {{'.format(i = index, length = length)
  76         try:
  77             self.visit(array.type, '%s[%s]' % (lvalue, index), '*__a%s->values[%s]' % (array.id, index))
  78         finally:
  79             print '        }'
  80             print '    } else {'
  81             print '        %s = NULL;' % lvalue
  82             print '    }'
  83
  84     def visit_pointer(self, pointer, lvalue, rvalue):
  85         print '    const Trace::Array *__a%s = dynamic_cast<const Trace::Array *>(&%s);' % (pointer.id, rvalue)
  86         print '    if (__a%s) {' % (pointer.id)
  87         print '        %s = new %s;' % (lvalue, pointer.type)
  88         try:
  89             self.visit(pointer.type, '%s[0]' % (lvalue,), '*__a%s->values[0]' % (pointer.id,))
  90         finally:
  91             print '    } else {'
  92             print '        %s = NULL;' % lvalue
  93             print '    }'
  94
  95     def visit_handle(self, handle, lvalue, rvalue):
  96         OpaqueValueExtractor().visit(handle.type, lvalue, rvalue);
  97         new_lvalue = handle_entry(handle, lvalue)
  98         print '    if (retrace::verbosity >= 2) {'
  99         print '        std::cout << "%s " << size_t(%s) << " <- " << size_t(%s) << "\\n";' % (handle.name, lvalue, new_lvalue)
 100         print '    }'
 101         print '    %s = %s;' % (lvalue, new_lvalue)
 102
 103     def visit_blob(self, blob, lvalue, rvalue):
 104         print '    %s = static_cast<%s>((%s).toPointer());' % (lvalue, blob, rvalue)
 105
 106     def visit_string(self, string, lvalue, rvalue):
 107         print '    %s = (%s)((%s).toString());' % (lvalue, string.expr, rvalue)
 108
 109
 110 class OpaqueValueExtractor(ValueExtractor):
 111     '''Value extractor that also understands opaque values.
 112
 113     Normally opaque values can't be retraced, unless they are being extracted
 114     in the context of handles.'''
 115
 116     def visit_opaque(self, opaque, lvalue, rvalue):
 117         print '    %s = static_cast<%s>((%s).toPointer());' % (lvalue, opaque, rvalue)
 118
 119
 120 class ValueWrapper(stdapi.Visitor):
 121
 122     def visit_literal(self, literal, lvalue, rvalue):
 123         pass
 124
 125     def visit_alias(self, alias, lvalue, rvalue):
 126         self.visit(alias.type, lvalue, rvalue)
 127
 128     def visit_enum(self, enum, lvalue, rvalue):
 129         pass
 130
 131     def visit_bitmask(self, bitmask, lvalue, rvalue):
 132         pass
 133
 134     def visit_array(self, array, lvalue, rvalue):
 135         print '    const Trace::Array *__a%s = dynamic_cast<const Trace::Array *>(&%s);' % (array.id, rvalue)
 136         print '    if (__a%s) {' % (array.id)
 137         length = '__a%s->values.size()' % array.id
 138         index = '__j' + array.id
 139         print '        for (size_t {i} = 0; {i} < {length}; ++{i}) {{'.format(i = index, length = length)
 140         try:
 141             self.visit(array.type, '%s[%s]' % (lvalue, index), '*__a%s->values[%s]' % (array.id, index))
 142         finally:
 143             print '        }'
 144             print '    }'
 145
 146     def visit_pointer(self, pointer, lvalue, rvalue):
 147         print '    const Trace::Array *__a%s = dynamic_cast<const Trace::Array *>(&%s);' % (pointer.id, rvalue)
 148         print '    if (__a%s) {' % (pointer.id)
 149         try:
 150             self.visit(pointer.type, '%s[0]' % (lvalue,), '*__a%s->values[0]' % (pointer.id,))
 151         finally:
 152             print '    }'
 153
 154     def visit_handle(self, handle, lvalue, rvalue):
 155         print '    %s __orig_result;' % handle.type
 156         OpaqueValueExtractor().visit(handle.type, '__orig_result', rvalue);
 157         if handle.range is None:
 158             rvalue = "__orig_result"
 159             entry = handle_entry(handle, rvalue)
 160             print "    %s = %s;" % (entry, lvalue)
 161             print '    if (retrace::verbosity >= 2) {'
 162             print '        std::cout << "{handle.name} " << {rvalue} << " -> " << {lvalue} << "\\n";'.format(**locals())
 163             print '    }'
 164         else:
 165             i = '__h' + handle.id
 166             lvalue = "%s + %s" % (lvalue, i)
 167             rvalue = "__orig_result + %s" % (i,)
 168             entry = handle_entry(handle, rvalue)
 169             print '    for ({handle.type} {i} = 0; {i} < {handle.range}; ++{i}) {{'.format(**locals())
 170             print '        {entry} = {lvalue};'.format(**locals())
 171             print '        if (retrace::verbosity >= 2) {'
 172             print '            std::cout << "{handle.name} " << ({rvalue}) << " -> " << ({lvalue}) << "\\n";'.format(**locals())
 173             print '        }'
 174             print '    }'
 175
 176     def visit_blob(self, blob, lvalue, rvalue):
 177         pass
 178
 179     def visit_string(self, string, lvalue, rvalue):
 180         pass
 181
 182
 183 class Retracer:
 184
 185     def retrace_function(self, function):
 186         print 'static void retrace_%s(Trace::Call &call) {' % function.name
 187         self.retrace_function_body(function)
 188         print '}'
 189         print
 190
 191     def retrace_function_body(self, function):
 192         if not function.sideeffects:
 193             return
 194
 195         success = True
 196         for arg in function.args:
 197             arg_type = ConstRemover().visit(arg.type)
 198             #print '    // %s ->  %s' % (arg.type, arg_type)
 199             print '    %s %s;' % (arg_type, arg.name)
 200             rvalue = 'call.arg(%u)' % (arg.index,)
 201             lvalue = arg.name
 202             try:
 203                 self.extract_arg(function, arg, arg_type, lvalue, rvalue)
 204             except NotImplementedError:
 205                 success = False
 206                 print '    %s = 0; // FIXME' % arg.name
 207         if not success:
 208             self.fail_function(function)
 209         self.call_function(function)
 210         for arg in function.args:
 211             if arg.output:
 212                 arg_type = ConstRemover().visit(arg.type)
 213                 rvalue = 'call.arg(%u)' % (arg.index,)
 214                 lvalue = arg.name
 215                 try:
 216                     ValueWrapper().visit(arg_type, lvalue, rvalue)
 217                 except NotImplementedError:
 218                     print '   // FIXME: %s' % arg.name
 219         if function.type is not stdapi.Void:
 220             rvalue = '*call.ret'
 221             lvalue = '__result'
 222             try:
 223                 ValueWrapper().visit(function.type, lvalue, rvalue)
 224             except NotImplementedError:
 225                 print '   // FIXME: result'
 226
 227     def fail_function(self, function):
 228         print '    if (retrace::verbosity >= 0)'
 229         print '        std::cerr << "warning: unsupported call %s\\n";' % function.name
 230         print '    return;'
 231
 232     def extract_arg(self, function, arg, arg_type, lvalue, rvalue):
 233         ValueExtractor().visit(arg_type, lvalue, rvalue)
 234
 235     def call_function(self, function):
 236         arg_names = ", ".join([arg.name for arg in function.args])
 237         if function.type is not stdapi.Void:
 238             print '    %s __result;' % (function.type)
 239             print '    __result = %s(%s);' % (function.name, arg_names)
 240             print '    (void)__result;'
 241         else:
 242             print '    %s(%s);' % (function.name, arg_names)
 243
 244     def filter_function(self, function):
 245         return True
 246
 247     def retrace_functions(self, functions):
 248         functions = filter(self.filter_function, functions)
 249
 250         for function in functions:
 251             self.retrace_function(function)
 252
 253         print 'void retrace::retrace_call(Trace::Call &call) {'
 254         print '    const char *name = call.name().c_str();'
 255         print
 256
 257         func_dict = dict([(function.name, function) for function in functions])
 258
 259         def handle_case(function_name):
 260             function = func_dict[function_name]
 261             print '        retrace_%s(call);' % function.name
 262             print '        return;'
 263
 264         string_switch('name', func_dict.keys(), handle_case)
 265
 266         print '    retrace_unknown(call);'
 267         print '}'
 268         print
 269
 270
 271     def retrace_api(self, api):
 272
 273         print '#include "trace_parser.hpp"'
 274         print '#include "retrace.hpp"'
 275         print
 276
 277         types = api.all_types()
 278         handles = [type for type in types if isinstance(type, stdapi.Handle)]
 279         handle_names = set()
 280         for handle in handles:
 281             if handle.name not in handle_names:
 282                 if handle.key is None:
 283                     print 'static retrace::map<%s> __%s_map;' % (handle.type, handle.name)
 284                 else:
 285                     key_name, key_type = handle.key
 286                     print 'static std::map<%s, retrace::map<%s> > __%s_map;' % (key_type, handle.type, handle.name)
 287                 handle_names.add(handle.name)
 288         print
 289
 290         self.retrace_functions(api.functions)
 291