import stdapi
import glapi
-import glstate
+import glparams
from glxapi import glxapi
from trace import Tracer, dump_instance
print ' void *map;'
print ' GLint length;'
print ' bool write;'
+ print ' bool explicit_flush;'
print '};'
print
for target in self.buffer_targets:
print 'static bool'
print 'is_symbolic_pname(GLenum pname) {'
print ' switch(pname) {'
- for function, type, count, name in glstate.parameters:
+ for function, type, count, name in glparams.parameters:
if type is glapi.GLenum:
print ' case %s:' % name
print ' return true;'
# Generate a helper function to know how many elements a parameter has
print 'static size_t'
- print 'pname_size(GLenum pname) {'
+ print '__gl_param_size(GLenum pname) {'
print ' switch(pname) {'
- for function, type, count, name in glstate.parameters:
+ for function, type, count, name in glparams.parameters:
if type is not None:
print ' case %s: return %u;' % (name, count)
print ' case GL_COMPRESSED_TEXTURE_FORMATS: {'
print '}'
print
-
array_pointer_function_names = set((
"glVertexPointer",
"glNormalPointer",
"glFogCoordPointer",
"glSecondaryColorPointer",
+ "glInterleavedArrays",
+
"glVertexPointerEXT",
"glNormalPointerEXT",
"glColorPointerEXT",
"glVertexAttribPointer",
"glVertexAttribPointerARB",
"glVertexAttribPointerNV",
+ "glVertexAttribIPointer",
+ "glVertexAttribIPointerEXT",
"glVertexAttribLPointer",
"glVertexAttribLPointerEXT",
draw_function_names = set((
'glDrawArrays',
- 'glDrawArraysEXT',
'glDrawElements',
'glDrawRangeElements',
+ 'glMultiDrawArrays',
+ 'glMultiDrawElements',
+ 'glDrawArraysInstanced',
+ 'glDrawElementsInstanced',
+ 'glDrawArraysInstancedARB',
+ 'glDrawElementsInstancedARB',
+ 'glDrawElementsBaseVertex',
+ 'glDrawRangeElementsBaseVertex',
+ 'glDrawElementsInstancedBaseVertex',
+ 'glMultiDrawElementsBaseVertex',
+ 'glDrawArraysIndirect',
+ 'glDrawElementsIndirect',
+ 'glDrawArraysEXT',
'glDrawRangeElementsEXT',
+ 'glDrawRangeElementsEXT_size',
+ 'glMultiDrawArraysEXT',
+ 'glMultiDrawElementsEXT',
+ 'glMultiModeDrawArraysIBM',
+ 'glMultiModeDrawElementsIBM',
+ 'glDrawArraysInstancedEXT',
+ 'glDrawElementsInstancedEXT',
))
interleaved_formats = [
print ' if (!__array_buffer) {'
print ' __user_arrays = true;'
self.dispatch_function(function)
+
+ # And also break down glInterleavedArrays into the individual calls
+ if function.name == 'glInterleavedArrays':
+ print
+
+ # Initialize the enable flags
+ for camelcase_name, uppercase_name in self.arrays:
+ flag_name = '__' + uppercase_name.lower()
+ print ' GLboolean %s = GL_FALSE;' % flag_name
+ print
+
+ # Switch for the interleaved formats
+ print ' switch (format) {'
+ for format in self.interleaved_formats:
+ print ' case %s:' % format
+ for camelcase_name, uppercase_name in self.arrays:
+ flag_name = '__' + uppercase_name.lower()
+ if format.find('_' + uppercase_name[0]) >= 0:
+ print ' %s = GL_TRUE;' % flag_name
+ print ' break;'
+ print ' default:'
+ print ' return;'
+ print ' }'
+ print
+
+ # Emit fake glEnableClientState/glDisableClientState flags
+ for camelcase_name, uppercase_name in self.arrays:
+ flag_name = '__' + uppercase_name.lower()
+ enable_name = 'GL_%s_ARRAY' % uppercase_name
+
+ # Emit a fake function
+ print ' {'
+ print ' static const Trace::FunctionSig &__sig = %s ? __glEnableClientState_sig : __glDisableClientState_sig;' % flag_name
+ print ' unsigned __call = __writer.beginEnter(&__sig);'
+ print ' __writer.beginArg(0);'
+ dump_instance(glapi.GLenum, enable_name)
+ print ' __writer.endArg();'
+ print ' __writer.endEnter();'
+ print ' __writer.beginLeave(__call);'
+ print ' __writer.endLeave();'
+ print ' }'
+
print ' return;'
print ' }'
print ' __trace_user_arrays(maxindex);'
print ' }'
- # And also break down glInterleavedArrays into the individual calls
- if function.name == 'glInterleavedArrays':
- print ' GLint __array_buffer = 0;'
- print ' __glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &__array_buffer);'
- print ' if (!__array_buffer) {'
- print ' __user_arrays = true;'
- self.dispatch_function(function)
- print
-
- # Initialize the enable flags
- for camelcase_name, uppercase_name in self.arrays:
- flag_name = '__' + uppercase_name.lower()
- print ' GLboolean %s = GL_FALSE;' % flag_name
- print
-
- # Swicth for the interleaved formats
- print ' switch (format) {'
- for format in self.interleaved_formats:
- print ' case %s:' % format
- for camelcase_name, uppercase_name in self.arrays:
- flag_name = '__' + uppercase_name.lower()
- if format.find('_' + uppercase_name[0]) >= 0:
- print ' %s = GL_TRUE;' % flag_name
- print ' break;'
- print ' default:'
- print ' return;'
- print ' }'
- print
-
- # Emit fake glEnableClientState/glDisableClientState flags
- for camelcase_name, uppercase_name in self.arrays:
- flag_name = '__' + uppercase_name.lower()
- enable_name = 'GL_%s_ARRAY' % uppercase_name
-
- # Emit a fake function
- print ' {'
- print ' static const Trace::FunctionSig &__sig = %s ? __glEnableClientState_sig : __glDisableClientState_sig;' % flag_name
- print ' unsigned __call = Trace::BeginEnter(__sig);'
- print ' Trace::BeginArg(0);'
- dump_instance(glapi.GLenum, enable_name)
- print ' Trace::EndArg();'
- print ' Trace::EndEnter();'
- print ' Trace::BeginLeave(__call);'
- print ' Trace::EndLeave();'
- print ' }'
-
- print ' return;'
+ # Emit a fake memcpy on buffer uploads
+ if function.name in ('glUnmapBuffer', 'glUnmapBufferARB', ):
+ print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
+ print ' if (mapping && mapping->write && !mapping->explicit_flush) {'
+ self.emit_memcpy('mapping->map', 'mapping->map', 'mapping->length')
print ' }'
-
- # Emit a fake memcpy on
- if function.name in ('glUnmapBuffer', 'glUnmapBufferARB'):
+ if function.name in ('glFlushMappedBufferRange', 'glFlushMappedBufferRangeAPPLE'):
+ # TODO: avoid copying [0, offset] bytes
print ' struct buffer_mapping *mapping = get_buffer_mapping(target);'
- print ' if (mapping && mapping->write) {'
- print ' unsigned __call = Trace::BeginEnter(__memcpy_sig);'
- print ' Trace::BeginArg(0);'
- print ' Trace::LiteralOpaque(mapping->map);'
- print ' Trace::EndArg();'
- print ' Trace::BeginArg(1);'
- print ' Trace::LiteralBlob(mapping->map, mapping->length);'
- print ' Trace::EndArg();'
- print ' Trace::BeginArg(2);'
- print ' Trace::LiteralUInt(mapping->length);'
- print ' Trace::EndArg();'
- print ' Trace::EndEnter();'
- print ' Trace::BeginLeave(__call);'
- print ' Trace::EndLeave();'
+ print ' if (mapping) {'
+ if function.name.endswith('APPLE'):
+ print ' GLsizeiptr length = size;'
+ print ' mapping->explicit_flush = true;'
+ print ' //assert(offset + length <= mapping->length);'
+ self.emit_memcpy('mapping->map', 'mapping->map', 'offset + length')
+ print ' }'
+ # FIXME: glFlushMappedNamedBufferRangeEXT
+
+ # Don't leave vertex attrib locations to chance. Instead emit fake
+ # glBindAttribLocation calls to ensure that the same locations will be
+ # used when retracing. Trying to remap locations after the fact would
+ # be an herculian task given that vertex attrib locations appear in
+ # many entry-points, including non-shader related ones.
+ if function.name == 'glLinkProgram':
+ Tracer.dispatch_function(self, function)
+ print ' GLint active_attributes = 0;'
+ print ' __glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &active_attributes);'
+ print ' for (GLuint attrib = 0; attrib < active_attributes; ++attrib) {'
+ print ' GLint size = 0;'
+ print ' GLenum type = 0;'
+ print ' GLchar name[256];'
+ # TODO: Use ACTIVE_ATTRIBUTE_MAX_LENGTH instead of 256
+ print ' __glGetActiveAttrib(program, attrib, sizeof name, NULL, &size, &type, name);'
+ print " if (name[0] != 'g' || name[1] != 'l' || name[2] != '_') {"
+ print ' GLint location = __glGetAttribLocation(program, name);'
+ print ' if (location >= 0) {'
+ bind_function = glapi.glapi.get_function_by_name('glBindAttribLocation')
+ self.fake_call(bind_function, ['program', 'location', 'name'])
+ print ' }'
+ print ' }'
+ print ' }'
+ if function.name == 'glLinkProgramARB':
+ Tracer.dispatch_function(self, function)
+ print ' GLint active_attributes = 0;'
+ print ' __glGetObjectParameterivARB(programObj, GL_OBJECT_ACTIVE_ATTRIBUTES_ARB, &active_attributes);'
+ print ' for (GLuint attrib = 0; attrib < active_attributes; ++attrib) {'
+ print ' GLint size = 0;'
+ print ' GLenum type = 0;'
+ print ' GLcharARB name[256];'
+ # TODO: Use ACTIVE_ATTRIBUTE_MAX_LENGTH instead of 256
+ print ' __glGetActiveAttribARB(programObj, attrib, sizeof name, NULL, &size, &type, name);'
+ print " if (name[0] != 'g' || name[1] != 'l' || name[2] != '_') {"
+ print ' GLint location = __glGetAttribLocationARB(programObj, name);'
+ print ' if (location >= 0) {'
+ bind_function = glapi.glapi.get_function_by_name('glBindAttribLocationARB')
+ self.fake_call(bind_function, ['programObj', 'location', 'name'])
+ print ' }'
+ print ' }'
print ' }'
Tracer.trace_function_impl_body(self, function)
+
+ def dispatch_function(self, function):
+ if function.name in ('glLinkProgram', 'glLinkProgramARB'):
+ # These functions have been dispatched already
+ return
+
+ Tracer.dispatch_function(self, function)
+
+ def emit_memcpy(self, dest, src, length):
+ print ' unsigned __call = __writer.beginEnter(&__memcpy_sig);'
+ print ' __writer.beginArg(0);'
+ print ' __writer.writeOpaque(%s);' % dest
+ print ' __writer.endArg();'
+ print ' __writer.beginArg(1);'
+ print ' __writer.writeBlob(%s, %s);' % (src, length)
+ print ' __writer.endArg();'
+ print ' __writer.beginArg(2);'
+ print ' __writer.writeUInt(%s);' % length
+ print ' __writer.endArg();'
+ print ' __writer.endEnter();'
+ print ' __writer.beginLeave(__call);'
+ print ' __writer.endLeave();'
buffer_targets = [
'ARRAY_BUFFER',
print ' mapping->length = 0;'
print ' __glGetBufferParameteriv(target, GL_BUFFER_SIZE, &mapping->length);'
print ' mapping->write = (access != GL_READ_ONLY);'
+ print ' mapping->explicit_flush = false;'
print ' }'
if function.name == 'glMapBufferRange':
print ' mapping->map = %s;' % (instance)
print ' mapping->length = length;'
print ' mapping->write = access & GL_MAP_WRITE_BIT;'
+ print ' mapping->explicit_flush = access & GL_MAP_FLUSH_EXPLICIT_BIT;'
print ' }'
boolean_names = [
def gl_boolean(self, value):
return self.boolean_names[int(bool(value))]
+ unpack_function_names = set([
+ 'glBitmap',
+ 'glDrawPixels',
+ 'glMultiTexImage1DEXT',
+ 'glMultiTexImage2DEXT',
+ 'glMultiTexImage3DEXT',
+ 'glMultiTexSubImage1DEXT',
+ 'glMultiTexSubImage2DEXT',
+ 'glMultiTexSubImage3DEXT',
+ 'glPolygonStipple',
+ 'glTexImage1D',
+ 'glTexImage1DEXT',
+ 'glTexImage2D',
+ 'glTexImage2DEXT',
+ 'glTexImage3D',
+ 'glTexImage3DEXT',
+ 'glTexSubImage1D',
+ 'glTexSubImage1DEXT',
+ 'glTexSubImage2D',
+ 'glTexSubImage2DEXT',
+ 'glTexSubImage3D',
+ 'glTexSubImage3DEXT',
+ 'glTextureImage1DEXT',
+ 'glTextureImage2DEXT',
+ 'glTextureImage3DEXT',
+ 'glTextureSubImage1DEXT',
+ 'glTextureSubImage2DEXT',
+ 'glTextureSubImage3DEXT',
+ ])
+
def dump_arg_instance(self, function, arg):
if function.name in self.draw_function_names and arg.name == 'indices':
print ' GLint __element_array_buffer = 0;'
print ' __glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &__element_array_buffer);'
print ' if (!__element_array_buffer) {'
- print ' Trace::LiteralBlob((const void *)%s, count*__gl_type_size(type));' % (arg.name)
+ if isinstance(arg.type, stdapi.Array):
+ print ' __writer.beginArray(%s);' % arg.type.length
+ print ' for(GLsizei i = 0; i < %s; ++i) {' % arg.type.length
+ print ' __writer.beginElement();'
+ print ' __writer.writeBlob(%s[i], count[i]*__gl_type_size(type));' % (arg.name)
+ print ' __writer.endElement();'
+ print ' }'
+ print ' __writer.endArray();'
+ else:
+ print ' __writer.writeBlob(%s, count*__gl_type_size(type));' % (arg.name)
print ' } else {'
- print ' Trace::LiteralOpaque((const void *)%s);' % (arg.name)
+ Tracer.dump_arg_instance(self, function, arg)
+ print ' }'
+ return
+
+ # Recognize offsets instead of blobs when a PBO is bound
+ if function.name in self.unpack_function_names \
+ and (isinstance(arg.type, stdapi.Blob) \
+ or (isinstance(arg.type, stdapi.Const) \
+ and isinstance(arg.type.type, stdapi.Blob))):
+ print ' GLint __unpack_buffer = 0;'
+ print ' __glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &__unpack_buffer);'
+ print ' if (__unpack_buffer) {'
+ print ' __writer.writeOpaque(%s);' % arg.name
+ print ' } else {'
+ Tracer.dump_arg_instance(self, function, arg)
print ' }'
return
# Several GL state functions take GLenum symbolic names as
# integer/floats; so dump the symbolic name whenever possible
- if arg.type in (glapi.GLint, glapi.GLfloat) and arg.name == 'param':
+ if function.name.startswith('gl') \
+ and arg.type in (glapi.GLint, glapi.GLfloat) \
+ and arg.name == 'param':
assert arg.index > 0
assert function.args[arg.index - 1].name == 'pname'
assert function.args[arg.index - 1].type == glapi.GLenum
# Emit a fake function
self.array_trace_intermezzo(api, uppercase_name)
- print ' unsigned __call = Trace::BeginEnter(__%s_sig);' % (function.name,)
+ print ' unsigned __call = __writer.beginEnter(&__%s_sig);' % (function.name,)
for arg in function.args:
assert not arg.output
- print ' Trace::BeginArg(%u);' % (arg.index,)
+ print ' __writer.beginArg(%u);' % (arg.index,)
if arg.name != 'pointer':
dump_instance(arg.type, arg.name)
else:
- print ' Trace::LiteralBlob((const void *)%s, __size);' % (arg.name)
- print ' Trace::EndArg();'
+ print ' __writer.writeBlob((const void *)%s, __size);' % (arg.name)
+ print ' __writer.endArg();'
- print ' Trace::EndEnter();'
- print ' Trace::BeginLeave(__call);'
- print ' Trace::EndLeave();'
+ print ' __writer.endEnter();'
+ print ' __writer.beginLeave(__call);'
+ print ' __writer.endLeave();'
print ' }'
print ' }'
self.array_epilog(api, uppercase_name)
print ' size_t __size = __%s_size(%s, maxindex);' % (function.name, arg_names)
# Emit a fake function
- print ' unsigned __call = Trace::BeginEnter(__%s_sig);' % (function.name,)
+ print ' unsigned __call = __writer.beginEnter(&__%s_sig);' % (function.name,)
for arg in function.args:
assert not arg.output
- print ' Trace::BeginArg(%u);' % (arg.index,)
+ print ' __writer.beginArg(%u);' % (arg.index,)
if arg.name != 'pointer':
dump_instance(arg.type, arg.name)
else:
- print ' Trace::LiteralBlob((const void *)%s, __size);' % (arg.name)
- print ' Trace::EndArg();'
+ print ' __writer.writeBlob((const void *)%s, __size);' % (arg.name)
+ print ' __writer.endArg();'
- print ' Trace::EndEnter();'
- print ' Trace::BeginLeave(__call);'
- print ' Trace::EndLeave();'
+ print ' __writer.endEnter();'
+ print ' __writer.beginLeave(__call);'
+ print ' __writer.endLeave();'
print ' }'
print ' }'
print ' }'
self.fake_call(function, [texture])
def fake_call(self, function, args):
- print ' unsigned __fake_call = Trace::BeginEnter(__%s_sig);' % (function.name,)
+ print ' unsigned __fake_call = __writer.beginEnter(&__%s_sig);' % (function.name,)
for arg, instance in zip(function.args, args):
assert not arg.output
- print ' Trace::BeginArg(%u);' % (arg.index,)
+ print ' __writer.beginArg(%u);' % (arg.index,)
dump_instance(arg.type, instance)
- print ' Trace::EndArg();'
- print ' Trace::EndEnter();'
- print ' Trace::BeginLeave(__fake_call);'
- print ' Trace::EndLeave();'
+ print ' __writer.endArg();'
+ print ' __writer.endEnter();'
+ print ' __writer.beginLeave(__fake_call);'
+ print ' __writer.endLeave();'
projects / apitrace / blobdiff