89301eaf21
The Android EGL shim injects GL_EXT_debug_marker into the ES driver EXTENSIONS string for the OpenGL ES 1.x and 2.0/3.0/3.1 drivers if the extension is not already provided. This feature is used by GLES_trace. In Open GL ES 3.0 it became possible to query an indexed version of the EXTENSIONS string via GetStringi(). NUM_EXTENSIONS Gets were also added to the specification (taken from Open GL). If the shim does not have to inject the extension, then there is no problem, as glGetString() and glGetStringi() / NUM_EXTENSIONS will be consistent. However, if the Android EGL shim injects the extension, NUM_EXTENSIONS and GetStringi() will report one less extension than is really available. Consistency between these methods is tested by the dEQP framework with the dEQP-GLES3.functional.state_query.string.extensions test. If the driver does not provide GL_EXT_debug_marker, this test fails. This change wraps all of the affected entry points so that the wrapped driver extensions are never visible directly to dEQP, eliminating the inconsistency.
329 lines
11 KiB
Python
Executable File
329 lines
11 KiB
Python
Executable File
#!/usr/bin/env python
|
|
#
|
|
# Copyright 2014 The Android Open Source Project
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
from __future__ import print_function
|
|
from operator import itemgetter
|
|
import collections
|
|
import os.path
|
|
import re
|
|
import sys
|
|
|
|
|
|
# Avoid endlessly adding to the path if this module is imported multiple
|
|
# times, e.g. in an interactive session
|
|
regpath = os.path.join(sys.path[0], "registry")
|
|
if sys.path[1] != regpath:
|
|
sys.path.insert(1, regpath)
|
|
import reg
|
|
|
|
|
|
AEP_EXTENSIONS = [
|
|
'GL_KHR_blend_equation_advanced',
|
|
'GL_KHR_debug',
|
|
'GL_KHR_texture_compression_astc_ldr',
|
|
'GL_OES_sample_shading',
|
|
'GL_OES_sample_variables',
|
|
'GL_OES_shader_image_atomic',
|
|
'GL_OES_shader_multisample_interpolation',
|
|
'GL_OES_texture_stencil8',
|
|
'GL_OES_texture_storage_multisample_2d_array',
|
|
'GL_EXT_copy_image',
|
|
'GL_EXT_draw_buffers_indexed',
|
|
'GL_EXT_geometry_shader',
|
|
'GL_EXT_gpu_shader5',
|
|
'GL_EXT_primitive_bounding_box',
|
|
'GL_EXT_shader_io_blocks',
|
|
'GL_EXT_tessellation_shader',
|
|
'GL_EXT_texture_border_clamp',
|
|
'GL_EXT_texture_buffer',
|
|
'GL_EXT_texture_cube_map_array',
|
|
'GL_EXT_texture_sRGB_decode']
|
|
|
|
|
|
def nonestr(s):
|
|
return s if s else ""
|
|
|
|
|
|
def parseTypedName(elem):
|
|
type = [nonestr(elem.text)]
|
|
name = None
|
|
for subelem in elem:
|
|
text = nonestr(subelem.text)
|
|
tail = nonestr(subelem.tail)
|
|
if subelem.tag == 'name':
|
|
name = text
|
|
break
|
|
else:
|
|
type.extend([text, tail])
|
|
return (''.join(type).strip(), name)
|
|
|
|
|
|
# Format a list of (type, name) tuples as a C-style parameter list
|
|
def fmtParams(params):
|
|
if not params:
|
|
return 'void'
|
|
return ', '.join(['%s %s' % (p[0], p[1]) for p in params])
|
|
|
|
# Format a list of (type, name) tuples as a C-style argument list
|
|
def fmtArgs(params):
|
|
return ', '.join(p[1] for p in params)
|
|
|
|
# Format a list of (type, name) tuples as comma-separated '"type", name'
|
|
def fmtTypeNameList(params):
|
|
return ', '.join(['"%s", %s' % (p[0], p[1]) for p in params])
|
|
|
|
|
|
def overrideSymbolName(sym, apiname):
|
|
# The wrapper intercepts various glGet and glGetString functions and
|
|
# (sometimes) calls the generated thunk which dispatches to the
|
|
# driver's implementation
|
|
wrapped_get_syms = {
|
|
'gles1' : [
|
|
'glGetString'
|
|
],
|
|
'gles2' : [
|
|
'glGetString',
|
|
'glGetStringi',
|
|
'glGetBooleanv',
|
|
'glGetFloatv',
|
|
'glGetIntegerv',
|
|
'glGetInteger64v',
|
|
],
|
|
}
|
|
if sym in wrapped_get_syms.get(apiname):
|
|
return '__' + sym
|
|
else:
|
|
return sym
|
|
|
|
|
|
# Generate API trampoline templates:
|
|
# <rtype> API_ENTRY(<name>)(<params>) {
|
|
# CALL_GL_API(<name>, <args>);
|
|
# // or
|
|
# CALL_GL_API_RETURN(<name>, <args>);
|
|
# }
|
|
class TrampolineGen(reg.OutputGenerator):
|
|
def __init__(self):
|
|
reg.OutputGenerator.__init__(self, sys.stderr, sys.stderr, None)
|
|
|
|
def genCmd(self, cmd, name):
|
|
reg.OutputGenerator.genCmd(self, cmd, name)
|
|
|
|
rtype, fname = parseTypedName(cmd.elem.find('proto'))
|
|
params = [parseTypedName(p) for p in cmd.elem.findall('param')]
|
|
|
|
call = 'CALL_GL_API' if rtype == 'void' else 'CALL_GL_API_RETURN'
|
|
print('%s API_ENTRY(%s)(%s) {\n'
|
|
' %s(%s%s%s);\n'
|
|
'}'
|
|
% (rtype, overrideSymbolName(fname, self.genOpts.apiname),
|
|
fmtParams(params), call, fname,
|
|
', ' if len(params) > 0 else '',
|
|
fmtArgs(params)),
|
|
file=self.outFile)
|
|
|
|
|
|
|
|
# Collect all API prototypes across all families, remove duplicates,
|
|
# emit to entries.in and trace.in files.
|
|
class ApiGenerator(reg.OutputGenerator):
|
|
def __init__(self):
|
|
reg.OutputGenerator.__init__(self, sys.stderr, sys.stderr, None)
|
|
self.cmds = []
|
|
self.enums = collections.OrderedDict()
|
|
|
|
def genCmd(self, cmd, name):
|
|
reg.OutputGenerator.genCmd(self, cmd, name)
|
|
rtype, fname = parseTypedName(cmd.elem.find('proto'))
|
|
params = [parseTypedName(p) for p in cmd.elem.findall('param')]
|
|
self.cmds.append({'rtype': rtype, 'name': fname, 'params': params})
|
|
|
|
def genEnum(self, enuminfo, name):
|
|
reg.OutputGenerator.genEnum(self, enuminfo, name)
|
|
value = enuminfo.elem.get('value')
|
|
|
|
# Skip bitmask enums. Pattern matches:
|
|
# - GL_DEPTH_BUFFER_BIT
|
|
# - GL_MAP_INVALIDATE_BUFFER_BIT_EXT
|
|
# - GL_COLOR_BUFFER_BIT1_QCOM
|
|
# but not
|
|
# - GL_DEPTH_BITS
|
|
# - GL_QUERY_COUNTER_BITS_EXT
|
|
#
|
|
# TODO: Assuming a naming pattern and using a regex is what the
|
|
# old glenumsgen script did. But the registry XML knows which enums are
|
|
# parts of bitmask groups, so we should just use that. I'm not sure how
|
|
# to get the information out though, and it's not critical right now,
|
|
# so leaving for later.
|
|
if re.search('_BIT($|\d*_)', name):
|
|
return
|
|
|
|
# Skip non-hex values (GL_TRUE, GL_FALSE, header guard junk)
|
|
if not re.search('0x[0-9A-Fa-f]+', value):
|
|
return
|
|
|
|
# Append 'u' or 'ull' type suffix if present
|
|
type = enuminfo.elem.get('type')
|
|
if type and type != 'i':
|
|
value += type
|
|
|
|
if value not in self.enums:
|
|
self.enums[value] = name
|
|
|
|
def finish(self):
|
|
# sort by function name, remove duplicates
|
|
self.cmds.sort(key=itemgetter('name'))
|
|
cmds = []
|
|
for cmd in self.cmds:
|
|
if len(cmds) == 0 or cmd != cmds[-1]:
|
|
cmds.append(cmd)
|
|
self.cmds = cmds
|
|
|
|
# Write entries.in
|
|
def writeEntries(self, outfile):
|
|
for cmd in self.cmds:
|
|
print('GL_ENTRY(%s, %s, %s)'
|
|
% (cmd['rtype'], cmd['name'], fmtParams(cmd['params'])),
|
|
file=outfile)
|
|
|
|
# Write traces.in
|
|
def writeTrace(self, outfile):
|
|
for cmd in self.cmds:
|
|
if cmd['rtype'] == 'void':
|
|
ret = '_VOID('
|
|
else:
|
|
ret = '(%s, ' % cmd['rtype']
|
|
|
|
params = cmd['params']
|
|
if len(params) > 0:
|
|
typeNameList = ', ' + fmtTypeNameList(params)
|
|
else:
|
|
typeNameList = ''
|
|
|
|
print('TRACE_GL%s%s, (%s), (%s), %d%s)'
|
|
% (ret, cmd['name'],
|
|
fmtParams(params), fmtArgs(params),
|
|
len(params), typeNameList),
|
|
file=outfile)
|
|
|
|
# Write enums.in
|
|
def writeEnums(self, outfile):
|
|
for enum in self.enums.iteritems():
|
|
print('GL_ENUM(%s,%s)' % (enum[0], enum[1]), file=outfile)
|
|
|
|
|
|
# Generate .spec entries for use by legacy 'gen' script
|
|
class SpecGenerator(reg.OutputGenerator):
|
|
def __init__(self):
|
|
reg.OutputGenerator.__init__(self, sys.stderr, sys.stderr, None)
|
|
|
|
def genCmd(self, cmd, name):
|
|
reg.OutputGenerator.genCmd(self, cmd, name)
|
|
rtype, fname = parseTypedName(cmd.elem.find('proto'))
|
|
params = [parseTypedName(p) for p in cmd.elem.findall('param')]
|
|
|
|
print('%s %s ( %s )' % (rtype, fname, fmtParams(params)),
|
|
file=self.outFile)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
registry = reg.Registry()
|
|
registry.loadFile('registry/gl.xml')
|
|
|
|
registry.setGenerator(TrampolineGen())
|
|
TRAMPOLINE_OPTIONS = [
|
|
reg.GeneratorOptions(
|
|
apiname = 'gles1',
|
|
profile = 'common',
|
|
filename = '../../libs/GLES_CM/gl_api.in'),
|
|
reg.GeneratorOptions(
|
|
apiname = 'gles1',
|
|
profile = 'common',
|
|
emitversions = None,
|
|
defaultExtensions = 'gles1',
|
|
filename = '../../libs/GLES_CM/glext_api.in'),
|
|
reg.GeneratorOptions(
|
|
apiname = 'gles2',
|
|
profile = 'common',
|
|
filename = '../../libs/GLES2/gl2_api.in'),
|
|
reg.GeneratorOptions(
|
|
apiname = 'gles2',
|
|
profile = 'common',
|
|
emitversions = None,
|
|
defaultExtensions = 'gles2',
|
|
filename = '../../libs/GLES2/gl2ext_api.in')]
|
|
for opts in TRAMPOLINE_OPTIONS:
|
|
registry.apiGen(opts)
|
|
|
|
apigen = ApiGenerator()
|
|
registry.setGenerator(apigen)
|
|
API_OPTIONS = [
|
|
# Generate non-extension versions of each API first, then extensions,
|
|
# so that if an extension enum was later standardized, we see the non-
|
|
# suffixed version first.
|
|
reg.GeneratorOptions(
|
|
apiname = 'gles1',
|
|
profile = 'common'),
|
|
reg.GeneratorOptions(
|
|
apiname = 'gles2',
|
|
profile = 'common'),
|
|
reg.GeneratorOptions(
|
|
apiname = 'gles1',
|
|
profile = 'common',
|
|
emitversions = None,
|
|
defaultExtensions = 'gles1'),
|
|
reg.GeneratorOptions(
|
|
apiname = 'gles2',
|
|
profile = 'common',
|
|
emitversions = None,
|
|
defaultExtensions = 'gles2')]
|
|
for opts in API_OPTIONS:
|
|
registry.apiGen(opts)
|
|
apigen.finish()
|
|
with open('../../libs/entries.in', 'w') as f:
|
|
apigen.writeEntries(f)
|
|
with open('../../libs/trace.in', 'w') as f:
|
|
apigen.writeTrace(f)
|
|
with open('../../libs/enums.in', 'w') as f:
|
|
apigen.writeEnums(f)
|
|
|
|
registry.setGenerator(SpecGenerator())
|
|
SPEC_OPTIONS = [
|
|
reg.GeneratorOptions(
|
|
apiname = 'gles2',
|
|
profile = 'common',
|
|
versions = '3\.1',
|
|
filename = '../glgen/specs/gles11/GLES31.spec'),
|
|
reg.GeneratorOptions(
|
|
apiname = 'gles2',
|
|
profile = 'common',
|
|
emitversions = None,
|
|
defaultExtensions = None,
|
|
addExtensions = '^({})$'.format('|'.join(AEP_EXTENSIONS)),
|
|
filename = '../glgen/specs/gles11/GLES31Ext.spec')]
|
|
# SpecGenerator creates a good starting point, but the CFunc.java parser is
|
|
# so terrible that the .spec file needs a lot of manual massaging before
|
|
# it works. Commenting this out to avoid accidentally overwriting all the
|
|
# manual modifications.
|
|
#
|
|
# Eventually this script should generate the Java and JNI code directly,
|
|
# skipping the intermediate .spec step, and obsoleting the existing
|
|
# ../glgen system.
|
|
#
|
|
# for opts in SPEC_OPTIONS:
|
|
# registry.apiGen(opts)
|
|
|