X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=retrace%2Fretrace.py;h=82910213a0d678e379b8a4f1d6e3c26183d1dec2;hb=3db3b2f03af32da02faa59b9bcbdd0e2879e280a;hp=369c13b44b90bb98c759b65d5cf706e840372807;hpb=9d27a54b0381610c30964880a5fdd4c27bb6e732;p=apitrace diff --git a/retrace/retrace.py b/retrace/retrace.py index 369c13b..8291021 100644 --- a/retrace/retrace.py +++ b/retrace/retrace.py @@ -41,31 +41,12 @@ class UnsupportedType(Exception): pass -class MutableRebuilder(stdapi.Rebuilder): - '''Type visitor which derives a mutable type.''' - - def visitConst(self, const): - # Strip out const qualifier - return const.type - - def visitAlias(self, alias): - # Tear the alias on type changes - type = self.visit(alias.type) - if type is alias.type: - return alias - return type - - def visitReference(self, reference): - # Strip out references - return reference.type - - def lookupHandle(handle, value): if handle.key is None: - return "__%s_map[%s]" % (handle.name, value) + return "_%s_map[%s]" % (handle.name, value) else: key_name, key_type = handle.key - return "__%s_map[%s][%s]" % (handle.name, key_name, value) + return "_%s_map[%s][%s]" % (handle.name, key_name, value) class ValueAllocator(stdapi.Visitor): @@ -141,13 +122,13 @@ class ValueDeserializer(stdapi.Visitor): def visitArray(self, array, lvalue, rvalue): - tmp = '__a_' + array.tag + '_' + str(self.seq) + tmp = '_a_' + array.tag + '_' + str(self.seq) self.seq += 1 print ' if (%s) {' % (lvalue,) print ' const trace::Array *%s = dynamic_cast(&%s);' % (tmp, rvalue) length = '%s->values.size()' % (tmp,) - index = '__j' + array.tag + index = '_j' + array.tag print ' for (size_t {i} = 0; {i} < {length}; ++{i}) {{'.format(i = index, length = length) try: self.visit(array.type, '%s[%s]' % (lvalue, index), '*%s->values[%s]' % (tmp, index)) @@ -156,7 +137,7 @@ class ValueDeserializer(stdapi.Visitor): print ' }' def visitPointer(self, pointer, lvalue, rvalue): - tmp = '__a_' + pointer.tag + '_' + str(self.seq) + tmp = '_a_' + pointer.tag + '_' + str(self.seq) self.seq += 1 print ' if (%s) {' % (lvalue,) @@ -201,7 +182,7 @@ class ValueDeserializer(stdapi.Visitor): seq = 0 def visitStruct(self, struct, lvalue, rvalue): - tmp = '__s_' + struct.tag + '_' + str(self.seq) + tmp = '_s_' + struct.tag + '_' + str(self.seq) self.seq += 1 print ' const trace::Struct *%s = dynamic_cast(&%s);' % (tmp, rvalue) @@ -244,22 +225,22 @@ class SwizzledValueRegistrator(stdapi.Visitor): pass def visitArray(self, array, lvalue, rvalue): - print ' const trace::Array *__a%s = dynamic_cast(&%s);' % (array.tag, rvalue) - print ' if (__a%s) {' % (array.tag) - length = '__a%s->values.size()' % array.tag - index = '__j' + array.tag + print ' const trace::Array *_a%s = dynamic_cast(&%s);' % (array.tag, rvalue) + print ' if (_a%s) {' % (array.tag) + length = '_a%s->values.size()' % array.tag + index = '_j' + array.tag print ' for (size_t {i} = 0; {i} < {length}; ++{i}) {{'.format(i = index, length = length) try: - self.visit(array.type, '%s[%s]' % (lvalue, index), '*__a%s->values[%s]' % (array.tag, index)) + self.visit(array.type, '%s[%s]' % (lvalue, index), '*_a%s->values[%s]' % (array.tag, index)) finally: print ' }' print ' }' def visitPointer(self, pointer, lvalue, rvalue): - print ' const trace::Array *__a%s = dynamic_cast(&%s);' % (pointer.tag, rvalue) - print ' if (__a%s) {' % (pointer.tag) + print ' const trace::Array *_a%s = dynamic_cast(&%s);' % (pointer.tag, rvalue) + print ' if (_a%s) {' % (pointer.tag) try: - self.visit(pointer.type, '%s[0]' % (lvalue,), '*__a%s->values[0]' % (pointer.tag,)) + self.visit(pointer.type, '%s[0]' % (lvalue,), '*_a%s->values[0]' % (pointer.tag,)) finally: print ' }' @@ -278,19 +259,19 @@ class SwizzledValueRegistrator(stdapi.Visitor): pass def visitHandle(self, handle, lvalue, rvalue): - print ' %s __orig_result;' % handle.type - OpaqueValueDeserializer().visit(handle.type, '__orig_result', rvalue); + print ' %s _origResult;' % handle.type + OpaqueValueDeserializer().visit(handle.type, '_origResult', rvalue); if handle.range is None: - rvalue = "__orig_result" + rvalue = "_origResult" entry = lookupHandle(handle, rvalue) print " %s = %s;" % (entry, lvalue) print ' if (retrace::verbosity >= 2) {' print ' std::cout << "{handle.name} " << {rvalue} << " -> " << {lvalue} << "\\n";'.format(**locals()) print ' }' else: - i = '__h' + handle.tag + i = '_h' + handle.tag lvalue = "%s + %s" % (lvalue, i) - rvalue = "__orig_result + %s" % (i,) + rvalue = "_origResult + %s" % (i,) entry = lookupHandle(handle, rvalue) print ' for ({handle.type} {i} = 0; {i} < {handle.range}; ++{i}) {{'.format(**locals()) print ' {entry} = {lvalue};'.format(**locals()) @@ -308,7 +289,7 @@ class SwizzledValueRegistrator(stdapi.Visitor): seq = 0 def visitStruct(self, struct, lvalue, rvalue): - tmp = '__s_' + struct.tag + '_' + str(self.seq) + tmp = '_s_' + struct.tag + '_' + str(self.seq) self.seq += 1 print ' const trace::Struct *%s = dynamic_cast(&%s);' % (tmp, rvalue) @@ -342,8 +323,12 @@ class Retracer: def retraceFunctionBody(self, function): assert function.sideeffects + if function.type is not stdapi.Void: + self.checkOrigResult(function) + self.deserializeArgs(function) + self.declareRet(function) self.invokeFunction(function) self.swizzleValues(function) @@ -351,14 +336,30 @@ class Retracer: def retraceInterfaceMethodBody(self, interface, method): assert method.sideeffects + if method.type is not stdapi.Void: + self.checkOrigResult(method) + self.deserializeThisPointer(interface) self.deserializeArgs(method) + self.declareRet(method) self.invokeInterfaceMethod(interface, method) self.swizzleValues(method) + def checkOrigResult(self, function): + '''Hook for checking the original result, to prevent succeeding now + where the original did not, which would cause diversion and potentially + unpredictable results.''' + + assert function.type is not stdapi.Void + + if str(function.type) == 'HRESULT': + print r' if (call.ret && FAILED(call.ret->toSInt())) {' + print r' return;' + print r' }' + def deserializeThisPointer(self, interface): print r' %s *_this;' % (interface.name,) print r' _this = static_cast<%s *>(_obj_map[call.arg(0).toUIntPtr()]);' % (interface.name,) @@ -372,7 +373,7 @@ class Retracer: print ' (void)_allocator;' success = True for arg in function.args: - arg_type = MutableRebuilder().visit(arg.type) + arg_type = arg.type.mutable() print ' %s %s;' % (arg_type, arg.name) rvalue = 'call.arg(%u)' % (arg.index,) lvalue = arg.name @@ -393,7 +394,7 @@ class Retracer: def swizzleValues(self, function): for arg in function.args: if arg.output: - arg_type = MutableRebuilder().visit(arg.type) + arg_type = arg.type.mutable() rvalue = 'call.arg(%u)' % (arg.index,) lvalue = arg.name try: @@ -402,7 +403,7 @@ class Retracer: print ' // XXX: %s' % arg.name if function.type is not stdapi.Void: rvalue = '*call.ret' - lvalue = '__result' + lvalue = '_result' try: self.regiterSwizzledValue(function.type, lvalue, rvalue) except UnsupportedType: @@ -431,21 +432,31 @@ class Retracer: visitor = SwizzledValueRegistrator() visitor.visit(type, lvalue, rvalue) + def declareRet(self, function): + if function.type is not stdapi.Void: + print ' %s _result;' % (function.type) + def invokeFunction(self, function): arg_names = ", ".join(function.argNames()) if function.type is not stdapi.Void: - print ' %s __result;' % (function.type) - print ' __result = %s(%s);' % (function.name, arg_names) - print ' (void)__result;' + print ' _result = %s(%s);' % (function.name, arg_names) + print ' (void)_result;' else: print ' %s(%s);' % (function.name, arg_names) def invokeInterfaceMethod(self, interface, method): + # On release our reference when we reach Release() == 0 call in the + # trace. + if method.name == 'Release': + print ' if (call.ret->toUInt()) {' + print ' return;' + print ' }' + print ' _obj_map.erase(call.arg(0).toUIntPtr());' + arg_names = ", ".join(method.argNames()) if method.type is not stdapi.Void: - print ' %s __result;' % (method.type) - print ' __result = _this->%s(%s);' % (method.name, arg_names) - print ' (void)__result;' + print ' _result = _this->%s(%s);' % (method.name, arg_names) + print ' (void)_result;' else: print ' _this->%s(%s);' % (method.name, arg_names) @@ -467,10 +478,10 @@ class Retracer: for handle in handles: if handle.name not in handle_names: if handle.key is None: - print 'static retrace::map<%s> __%s_map;' % (handle.type, handle.name) + print 'static retrace::map<%s> _%s_map;' % (handle.type, handle.name) else: key_name, key_type = handle.key - print 'static std::map<%s, retrace::map<%s> > __%s_map;' % (key_type, handle.type, handle.name) + print 'static std::map<%s, retrace::map<%s> > _%s_map;' % (key_type, handle.type, handle.name) handle_names.add(handle.name) print @@ -479,20 +490,21 @@ class Retracer: functions = filter(self.filterFunction, api.functions) for function in functions: - if function.sideeffects: + if function.sideeffects and not function.internal: self.retraceFunction(function) interfaces = api.getAllInterfaces() for interface in interfaces: for method in interface.iterMethods(): - if method.sideeffects: + if method.sideeffects and not method.internal: self.retraceInterfaceMethod(interface, method) print 'const retrace::Entry %s[] = {' % self.table_name for function in functions: - if function.sideeffects: - print ' {"%s", &retrace_%s},' % (function.name, function.name) - else: - print ' {"%s", &retrace::ignore},' % (function.name,) + if not function.internal: + if function.sideeffects: + print ' {"%s", &retrace_%s},' % (function.name, function.name) + else: + print ' {"%s", &retrace::ignore},' % (function.name,) for interface in interfaces: for method in interface.iterMethods(): if method.sideeffects: