X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=retrace%2Fretrace.py;h=d09d72aa2ca46aff0c10380463b51cfcb455c1c7;hb=37007777c37b1d28abfe1ac07901d1e13e12b113;hp=369c13b44b90bb98c759b65d5cf706e840372807;hpb=9d27a54b0381610c30964880a5fdd4c27bb6e732;p=apitrace diff --git a/retrace/retrace.py b/retrace/retrace.py index 369c13b..d09d72a 100644 --- a/retrace/retrace.py +++ b/retrace/retrace.py @@ -34,38 +34,18 @@ sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..')) import specs.stdapi as stdapi -import specs.glapi as glapi 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): @@ -86,10 +66,10 @@ class ValueAllocator(stdapi.Visitor): pass def visitArray(self, array, lvalue, rvalue): - print ' %s = _allocator.alloc<%s>(&%s);' % (lvalue, array.type, rvalue) + print ' %s = static_cast<%s *>(_allocator.alloc(&%s, sizeof *%s));' % (lvalue, array.type, rvalue, lvalue) def visitPointer(self, pointer, lvalue, rvalue): - print ' %s = _allocator.alloc<%s>(&%s);' % (lvalue, pointer.type, rvalue) + print ' %s = static_cast<%s *>(_allocator.alloc(&%s, sizeof *%s));' % (lvalue, pointer.type, rvalue, lvalue) def visitIntPointer(self, pointer, lvalue, rvalue): pass @@ -116,13 +96,14 @@ class ValueAllocator(stdapi.Visitor): pass def visitPolymorphic(self, polymorphic, lvalue, rvalue): + assert polymorphic.defaultType is not None self.visit(polymorphic.defaultType, lvalue, rvalue) def visitOpaque(self, opaque, lvalue, rvalue): pass -class ValueDeserializer(stdapi.Visitor): +class ValueDeserializer(stdapi.Visitor, stdapi.ExpanderMixin): def visitLiteral(self, literal, lvalue, rvalue): print ' %s = (%s).to%s();' % (lvalue, rvalue, literal.kind) @@ -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,) @@ -170,12 +151,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) @@ -190,7 +166,14 @@ class ValueDeserializer(stdapi.Visitor): print ' if (retrace::verbosity >= 2) {' print ' std::cout << "%s " << size_t(%s) << " <- " << size_t(%s) << "\\n";' % (handle.name, lvalue, new_lvalue) print ' }' - print ' %s = %s;' % (lvalue, new_lvalue) + if (new_lvalue.startswith('_program_map') or new_lvalue.startswith('_shader_map')): + print 'if (glretrace::supportsARBShaderObjects) {' + print ' %s = _handleARB_map[%s];' % (lvalue, lvalue) + print '} else {' + print ' %s = %s;' % (lvalue, new_lvalue) + print '}' + else: + print ' %s = %s;' % (lvalue, new_lvalue) def visitBlob(self, blob, lvalue, rvalue): print ' %s = static_cast<%s>((%s).toPointer());' % (lvalue, blob, rvalue) @@ -201,17 +184,38 @@ 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) print ' assert(%s);' % (tmp) for i in range(len(struct.members)): - member_type, member_name = struct.members[i] - self.visit(member_type, '%s.%s' % (lvalue, member_name), '*%s->members[%s]' % (tmp, i)) + member = struct.members[i] + self.visitMember(member, lvalue, '*%s->members[%s]' % (tmp, i)) def visitPolymorphic(self, polymorphic, lvalue, rvalue): - self.visit(polymorphic.defaultType, lvalue, rvalue) + if polymorphic.defaultType is None: + switchExpr = self.expand(polymorphic.switchExpr) + print r' switch (%s) {' % switchExpr + for cases, type in polymorphic.iterSwitch(): + for case in cases: + print r' %s:' % case + caseLvalue = lvalue + if type.expr is not None: + caseLvalue = 'static_cast<%s>(%s)' % (type, caseLvalue) + print r' {' + try: + self.visit(type, caseLvalue, rvalue) + finally: + print r' }' + print r' break;' + if polymorphic.defaultType is None: + print r' default:' + print r' retrace::warning(call) << "unexpected polymorphic case" << %s << "\n";' % (switchExpr,) + print r' break;' + print r' }' + else: + self.visit(polymorphic.defaultType, lvalue, rvalue) def visitOpaque(self, opaque, lvalue, rvalue): raise UnsupportedType @@ -227,7 +231,7 @@ class OpaqueValueDeserializer(ValueDeserializer): print ' %s = static_cast<%s>(retrace::toPointer(%s));' % (lvalue, opaque, rvalue) -class SwizzledValueRegistrator(stdapi.Visitor): +class SwizzledValueRegistrator(stdapi.Visitor, stdapi.ExpanderMixin): '''Type visitor which will register (un)swizzled value pairs, to later be swizzled.''' @@ -244,22 +248,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 ' }' @@ -267,7 +271,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 @@ -278,19 +282,26 @@ 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" - entry = lookupHandle(handle, rvalue) - print " %s = %s;" % (entry, lvalue) + rvalue = "_origResult" + entry = lookupHandle(handle, rvalue) + if (entry.startswith('_program_map') or entry.startswith('_shader_map')): + print 'if (glretrace::supportsARBShaderObjects) {' + print ' _handleARB_map[%s] = %s;' % (rvalue, lvalue) + print '} else {' + print ' %s = %s;' % (entry, lvalue) + print '}' + else: + 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,17 +319,18 @@ 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) print ' assert(%s);' % (tmp,) print ' (void)%s;' % (tmp,) for i in range(len(struct.members)): - member_type, member_name = struct.members[i] - self.visit(member_type, '%s.%s' % (lvalue, member_name), '*%s->members[%s]' % (tmp, i)) + member = struct.members[i] + self.visitMember(member, lvalue, '*%s->members[%s]' % (tmp, i)) def visitPolymorphic(self, polymorphic, lvalue, rvalue): + assert polymorphic.defaultType is not None self.visit(polymorphic.defaultType, lvalue, rvalue) def visitOpaque(self, opaque, lvalue, rvalue): @@ -342,8 +354,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,19 +367,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' }' @@ -372,7 +403,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 @@ -386,14 +417,13 @@ class Retracer: if not success: print ' if (1) {' self.failFunction(function) - if function.name[-1].islower(): - sys.stderr.write('warning: unsupported %s call\n' % function.name) + sys.stderr.write('warning: unsupported %s call\n' % function.name) print ' }' 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 +432,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,24 +461,42 @@ 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) 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 ' 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 @@ -459,6 +507,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() @@ -467,32 +516,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: