X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=retrace%2Fretrace.py;h=c4ad2d2bb494aceb861dcf163818bb702af58622;hb=944088ed749f195699228598ce3955063696931b;hp=2e0350107a64f7e17ced6f9145acc462053816e2;hpb=7bd3b9c302b5e4f252736de06ec9233732164140;p=apitrace diff --git a/retrace/retrace.py b/retrace/retrace.py index 2e03501..c4ad2d2 100644 --- a/retrace/retrace.py +++ b/retrace/retrace.py @@ -34,7 +34,6 @@ sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..')) import specs.stdapi as stdapi -import specs.glapi as glapi class UnsupportedType(Exception): @@ -43,10 +42,10 @@ class UnsupportedType(Exception): 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): @@ -122,13 +121,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)) @@ -137,7 +136,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,) @@ -151,12 +150,7 @@ class ValueDeserializer(stdapi.Visitor): print ' %s = static_cast<%s>((%s).toPointer());' % (lvalue, pointer, rvalue) def visitObjPointer(self, pointer, lvalue, rvalue): - old_lvalue = '(%s).toUIntPtr()' % (rvalue,) - new_lvalue = '_obj_map[%s]' % (old_lvalue,) - print ' if (retrace::verbosity >= 2) {' - print ' std::cout << std::hex << "obj 0x" << size_t(%s) << " <- 0x" << size_t(%s) << std::dec <<"\\n";' % (old_lvalue, new_lvalue) - print ' }' - print ' %s = static_cast<%s>(%s);' % (lvalue, pointer, new_lvalue) + print ' %s = static_cast<%s>(retrace::toObjPointer(call, %s));' % (lvalue, pointer, rvalue) def visitLinearPointer(self, pointer, lvalue, rvalue): print ' %s = static_cast<%s>(retrace::toPointer(%s));' % (lvalue, pointer, rvalue) @@ -182,7 +176,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) @@ -225,22 +219,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 ' }' @@ -248,7 +242,7 @@ class SwizzledValueRegistrator(stdapi.Visitor): pass def visitObjPointer(self, pointer, lvalue, rvalue): - print r' _obj_map[(%s).toUIntPtr()] = %s;' % (rvalue, lvalue) + print r' retrace::addObj(call, %s, %s);' % (rvalue, lvalue) def visitLinearPointer(self, pointer, lvalue, rvalue): assert pointer.size is not None @@ -259,19 +253,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()) @@ -289,7 +283,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) @@ -323,8 +317,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) @@ -332,19 +330,34 @@ 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,) + print r' _this = static_cast<%s *>(retrace::toObjPointer(call, call.arg(0)));' % (interface.name,) print r' if (!_this) {' - print r' retrace::warning(call) << "NULL this pointer\n";' print r' return;' print r' }' @@ -383,7 +396,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: @@ -412,12 +425,16 @@ 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;' + self.checkResult(function.type) else: print ' %s(%s);' % (function.name, arg_names) @@ -428,16 +445,22 @@ class Retracer: print ' if (call.ret->toUInt()) {' print ' return;' print ' }' - print ' _obj_map.erase(call.arg(0).toUIntPtr());' + print ' retrace::delObj(call.arg(0));' 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;' + self.checkResult(method.type) else: print ' _this->%s(%s);' % (method.name, arg_names) + def checkResult(self, resultType): + if str(resultType) == 'HRESULT': + print r' if (FAILED(_result)) {' + print r' retrace::warning(call) << "failed\n";' + print r' }' + def filterFunction(self, function): return True @@ -448,6 +471,7 @@ class Retracer: print '#include "os_time.hpp"' print '#include "trace_parser.hpp"' print '#include "retrace.hpp"' + print '#include "retrace_swizzle.hpp"' print types = api.getAllTypes() @@ -456,32 +480,30 @@ 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 - print 'static std::map _obj_map;' - print - - functions = filter(self.filterFunction, api.functions) + functions = filter(self.filterFunction, api.getAllFunctions()) 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: