Entry Points: Speed up auto-gen.

scripts/generate_entry_points.py

@@ -236,20 +236,27 @@ def format_entry_point_def_oldstyle(cmd_name, proto, params):
 def path_to(folder, file):
     return os.path.join(script_relative(".."), "src", folder, file)
 
+all_commands = root.findall('commands/command')
+
 for major_version, minor_version in [[2, 0], [3, 0], [3, 1]]:
     gles_xpath = ".//feature[@name='GL_ES_VERSION_{}_{}']//command".format(major_version, minor_version)
     gles_commands = [cmd.attrib['name'] for cmd in root.findall(gles_xpath)]
 
     entry_point_decls = []
     entry_point_defs = []
-    for cmd_name in gles_commands:
-        command_xpath = "command/proto[name='" + cmd_name + "']/.."
-        command = commands.find(command_xpath)
-        params = ["".join(param.itertext()) for param in command.findall("./param")]
-        proto = "".join(command.find("./proto").itertext())
+
+    for command in all_commands:
+        proto = command.find('proto')
+        cmd_name = proto.find('name').text
+
+        if cmd_name not in gles_commands:
+            continue
+
+        param_text = ["".join(param.itertext()) for param in command.findall('param')]
+        proto_text = "".join(proto.itertext())
         cmd_names += [cmd_name]
-        entry_point_decls += [format_entry_point_decl(cmd_name, proto, params)]
-        entry_point_defs += [format_entry_point_def(cmd_name, proto, params)]
+        entry_point_decls += [format_entry_point_decl(cmd_name, proto_text, param_text)]
+        entry_point_defs += [format_entry_point_def(cmd_name, proto_text, param_text)]
 
     for type in ["header", "source"]:
         if type == "header":
@@ -284,7 +291,7 @@ for major_version, minor_version in [[2, 0], [3, 0], [3, 1]]:
             out.close()
 
 # TODO(jmadill): Remove manually added entry points once we auto-gen them.
-manual_cmd_names = ["Invalid"] + [cmd[2:] for cmd in cmd_names] + ["DrawElementsInstancedANGLE"]
+manual_cmd_names = ["Invalid"] + [cmd[2:] for cmd in sorted(cmd_names)] + ["DrawElementsInstancedANGLE"]
 entry_points_enum = template_entry_points_enum_header.format(
     script_name = os.path.basename(sys.argv[0]),
     data_source_name = "gl.xml",

src/libANGLE/entry_points_enum_autogen.h

@@ -16,102 +16,239 @@ namespace gl
 enum class EntryPoint
 {
     Invalid,
+    ActiveShaderProgram,
     ActiveTexture,
     AttachShader,
+    BeginQuery,
+    BeginTransformFeedback,
     BindAttribLocation,
     BindBuffer,
+    BindBufferBase,
+    BindBufferRange,
     BindFramebuffer,
+    BindImageTexture,
+    BindProgramPipeline,
     BindRenderbuffer,
+    BindSampler,
     BindTexture,
+    BindTransformFeedback,
+    BindVertexArray,
+    BindVertexBuffer,
     BlendColor,
     BlendEquation,
     BlendEquationSeparate,
     BlendFunc,
     BlendFuncSeparate,
+    BlitFramebuffer,
     BufferData,
     BufferSubData,
     CheckFramebufferStatus,
     Clear,
+    ClearBufferfi,
+    ClearBufferfv,
+    ClearBufferiv,
+    ClearBufferuiv,
     ClearColor,
     ClearDepthf,
     ClearStencil,
+    ClientWaitSync,
     ColorMask,
     CompileShader,
     CompressedTexImage2D,
+    CompressedTexImage3D,
     CompressedTexSubImage2D,
+    CompressedTexSubImage3D,
+    CopyBufferSubData,
     CopyTexImage2D,
     CopyTexSubImage2D,
+    CopyTexSubImage3D,
     CreateProgram,
     CreateShader,
+    CreateShaderProgramv,
     CullFace,
     DeleteBuffers,
     DeleteFramebuffers,
     DeleteProgram,
+    DeleteProgramPipelines,
+    DeleteQueries,
     DeleteRenderbuffers,
+    DeleteSamplers,
     DeleteShader,
+    DeleteSync,
     DeleteTextures,
+    DeleteTransformFeedbacks,
+    DeleteVertexArrays,
     DepthFunc,
     DepthMask,
     DepthRangef,
     DetachShader,
     Disable,
     DisableVertexAttribArray,
+    DispatchCompute,
+    DispatchComputeIndirect,
     DrawArrays,
+    DrawArraysIndirect,
+    DrawArraysInstanced,
+    DrawBuffers,
     DrawElements,
+    DrawElementsIndirect,
+    DrawElementsInstanced,
+    DrawRangeElements,
     Enable,
     EnableVertexAttribArray,
+    EndQuery,
+    EndTransformFeedback,
+    FenceSync,
     Finish,
     Flush,
+    FlushMappedBufferRange,
+    FramebufferParameteri,
     FramebufferRenderbuffer,
     FramebufferTexture2D,
+    FramebufferTextureLayer,
     FrontFace,
     GenBuffers,
-    GenerateMipmap,
     GenFramebuffers,
+    GenProgramPipelines,
+    GenQueries,
     GenRenderbuffers,
+    GenSamplers,
     GenTextures,
+    GenTransformFeedbacks,
+    GenVertexArrays,
+    GenerateMipmap,
     GetActiveAttrib,
     GetActiveUniform,
+    GetActiveUniformBlockName,
+    GetActiveUniformBlockiv,
+    GetActiveUniformsiv,
     GetAttachedShaders,
     GetAttribLocation,
+    GetBooleani_v,
     GetBooleanv,
+    GetBufferParameteri64v,
     GetBufferParameteriv,
+    GetBufferPointerv,
     GetError,
     GetFloatv,
+    GetFragDataLocation,
     GetFramebufferAttachmentParameteriv,
+    GetFramebufferParameteriv,
+    GetInteger64i_v,
+    GetInteger64v,
+    GetIntegeri_v,
     GetIntegerv,
-    GetProgramiv,
+    GetInternalformativ,
+    GetMultisamplefv,
+    GetProgramBinary,
     GetProgramInfoLog,
+    GetProgramInterfaceiv,
+    GetProgramPipelineInfoLog,
+    GetProgramPipelineiv,
+    GetProgramResourceIndex,
+    GetProgramResourceLocation,
+    GetProgramResourceName,
+    GetProgramResourceiv,
+    GetProgramiv,
+    GetQueryObjectuiv,
+    GetQueryiv,
     GetRenderbufferParameteriv,
-    GetShaderiv,
+    GetSamplerParameterfv,
+    GetSamplerParameteriv,
     GetShaderInfoLog,
     GetShaderPrecisionFormat,
     GetShaderSource,
+    GetShaderiv,
     GetString,
+    GetStringi,
+    GetSynciv,
+    GetTexLevelParameterfv,
+    GetTexLevelParameteriv,
     GetTexParameterfv,
     GetTexParameteriv,
+    GetTransformFeedbackVarying,
+    GetUniformBlockIndex,
+    GetUniformIndices,
+    GetUniformLocation,
     GetUniformfv,
     GetUniformiv,
-    GetUniformLocation,
+    GetUniformuiv,
+    GetVertexAttribIiv,
+    GetVertexAttribIuiv,
+    GetVertexAttribPointerv,
     GetVertexAttribfv,
     GetVertexAttribiv,
-    GetVertexAttribPointerv,
     Hint,
+    InvalidateFramebuffer,
+    InvalidateSubFramebuffer,
     IsBuffer,
     IsEnabled,
     IsFramebuffer,
     IsProgram,
+    IsProgramPipeline,
+    IsQuery,
     IsRenderbuffer,
+    IsSampler,
     IsShader,
+    IsSync,
     IsTexture,
+    IsTransformFeedback,
+    IsVertexArray,
     LineWidth,
     LinkProgram,
+    MapBufferRange,
+    MemoryBarrier,
+    MemoryBarrierByRegion,
+    PauseTransformFeedback,
     PixelStorei,
     PolygonOffset,
+    ProgramBinary,
+    ProgramParameteri,
+    ProgramUniform1f,
+    ProgramUniform1fv,
+    ProgramUniform1i,
+    ProgramUniform1iv,
+    ProgramUniform1ui,
+    ProgramUniform1uiv,
+    ProgramUniform2f,
+    ProgramUniform2fv,
+    ProgramUniform2i,
+    ProgramUniform2iv,
+    ProgramUniform2ui,
+    ProgramUniform2uiv,
+    ProgramUniform3f,
+    ProgramUniform3fv,
+    ProgramUniform3i,
+    ProgramUniform3iv,
+    ProgramUniform3ui,
+    ProgramUniform3uiv,
+    ProgramUniform4f,
+    ProgramUniform4fv,
+    ProgramUniform4i,
+    ProgramUniform4iv,
+    ProgramUniform4ui,
+    ProgramUniform4uiv,
+    ProgramUniformMatrix2fv,
+    ProgramUniformMatrix2x3fv,
+    ProgramUniformMatrix2x4fv,
+    ProgramUniformMatrix3fv,
+    ProgramUniformMatrix3x2fv,
+    ProgramUniformMatrix3x4fv,
+    ProgramUniformMatrix4fv,
+    ProgramUniformMatrix4x2fv,
+    ProgramUniformMatrix4x3fv,
+    ReadBuffer,
     ReadPixels,
     ReleaseShaderCompiler,
     RenderbufferStorage,
+    RenderbufferStorageMultisample,
+    ResumeTransformFeedback,
     SampleCoverage,
+    SampleMaski,
+    SamplerParameterf,
+    SamplerParameterfv,
+    SamplerParameteri,
+    SamplerParameteriv,
     Scissor,
     ShaderBinary,
     ShaderSource,
@@ -122,32 +259,56 @@ enum class EntryPoint
     StencilOp,
     StencilOpSeparate,
     TexImage2D,
+    TexImage3D,
     TexParameterf,
     TexParameterfv,
     TexParameteri,
     TexParameteriv,
+    TexStorage2D,
+    TexStorage2DMultisample,
+    TexStorage3D,
     TexSubImage2D,
+    TexSubImage3D,
+    TransformFeedbackVaryings,
     Uniform1f,
     Uniform1fv,
     Uniform1i,
     Uniform1iv,
+    Uniform1ui,
+    Uniform1uiv,
     Uniform2f,
     Uniform2fv,
     Uniform2i,
     Uniform2iv,
+    Uniform2ui,
+    Uniform2uiv,
     Uniform3f,
     Uniform3fv,
     Uniform3i,
     Uniform3iv,
+    Uniform3ui,
+    Uniform3uiv,
     Uniform4f,
     Uniform4fv,
     Uniform4i,
     Uniform4iv,
+    Uniform4ui,
+    Uniform4uiv,
+    UniformBlockBinding,
     UniformMatrix2fv,
+    UniformMatrix2x3fv,
+    UniformMatrix2x4fv,
     UniformMatrix3fv,
+    UniformMatrix3x2fv,
+    UniformMatrix3x4fv,
     UniformMatrix4fv,
+    UniformMatrix4x2fv,
+    UniformMatrix4x3fv,
+    UnmapBuffer,
     UseProgram,
+    UseProgramStages,
     ValidateProgram,
+    ValidateProgramPipeline,
     VertexAttrib1f,
     VertexAttrib1fv,
     VertexAttrib2f,
@@ -156,180 +317,19 @@ enum class EntryPoint
     VertexAttrib3fv,
     VertexAttrib4f,
     VertexAttrib4fv,
-    VertexAttribPointer,
-    Viewport,
-    ReadBuffer,
-    DrawRangeElements,
-    TexImage3D,
-    TexSubImage3D,
-    CopyTexSubImage3D,
-    CompressedTexImage3D,
-    CompressedTexSubImage3D,
-    GenQueries,
-    DeleteQueries,
-    IsQuery,
-    BeginQuery,
-    EndQuery,
-    GetQueryiv,
-    GetQueryObjectuiv,
-    UnmapBuffer,
-    GetBufferPointerv,
-    DrawBuffers,
-    UniformMatrix2x3fv,
-    UniformMatrix3x2fv,
-    UniformMatrix2x4fv,
-    UniformMatrix4x2fv,
-    UniformMatrix3x4fv,
-    UniformMatrix4x3fv,
-    BlitFramebuffer,
-    RenderbufferStorageMultisample,
-    FramebufferTextureLayer,
-    MapBufferRange,
-    FlushMappedBufferRange,
-    BindVertexArray,
-    DeleteVertexArrays,
-    GenVertexArrays,
-    IsVertexArray,
-    GetIntegeri_v,
-    BeginTransformFeedback,
-    EndTransformFeedback,
-    BindBufferRange,
-    BindBufferBase,
-    TransformFeedbackVaryings,
-    GetTransformFeedbackVarying,
-    VertexAttribIPointer,
-    GetVertexAttribIiv,
-    GetVertexAttribIuiv,
+    VertexAttribBinding,
+    VertexAttribDivisor,
+    VertexAttribFormat,
     VertexAttribI4i,
-    VertexAttribI4ui,
     VertexAttribI4iv,
+    VertexAttribI4ui,
     VertexAttribI4uiv,
-    GetUniformuiv,
-    GetFragDataLocation,
-    Uniform1ui,
-    Uniform2ui,
-    Uniform3ui,
-    Uniform4ui,
-    Uniform1uiv,
-    Uniform2uiv,
-    Uniform3uiv,
-    Uniform4uiv,
-    ClearBufferiv,
-    ClearBufferuiv,
-    ClearBufferfv,
-    ClearBufferfi,
-    GetStringi,
-    CopyBufferSubData,
-    GetUniformIndices,
-    GetActiveUniformsiv,
-    GetUniformBlockIndex,
-    GetActiveUniformBlockiv,
-    GetActiveUniformBlockName,
-    UniformBlockBinding,
-    DrawArraysInstanced,
-    DrawElementsInstanced,
-    FenceSync,
-    IsSync,
-    DeleteSync,
-    ClientWaitSync,
-    WaitSync,
-    GetInteger64v,
-    GetSynciv,
-    GetInteger64i_v,
-    GetBufferParameteri64v,
-    GenSamplers,
-    DeleteSamplers,
-    IsSampler,
-    BindSampler,
-    SamplerParameteri,
-    SamplerParameteriv,
-    SamplerParameterf,
-    SamplerParameterfv,
-    GetSamplerParameteriv,
-    GetSamplerParameterfv,
-    VertexAttribDivisor,
-    BindTransformFeedback,
-    DeleteTransformFeedbacks,
-    GenTransformFeedbacks,
-    IsTransformFeedback,
-    PauseTransformFeedback,
-    ResumeTransformFeedback,
-    GetProgramBinary,
-    ProgramBinary,
-    ProgramParameteri,
-    InvalidateFramebuffer,
-    InvalidateSubFramebuffer,
-    TexStorage2D,
-    TexStorage3D,
-    GetInternalformativ,
-    DispatchCompute,
-    DispatchComputeIndirect,
-    DrawArraysIndirect,
-    DrawElementsIndirect,
-    FramebufferParameteri,
-    GetFramebufferParameteriv,
-    GetProgramInterfaceiv,
-    GetProgramResourceIndex,
-    GetProgramResourceName,
-    GetProgramResourceiv,
-    GetProgramResourceLocation,
-    UseProgramStages,
-    ActiveShaderProgram,
-    CreateShaderProgramv,
-    BindProgramPipeline,
-    DeleteProgramPipelines,
-    GenProgramPipelines,
-    IsProgramPipeline,
-    GetProgramPipelineiv,
-    ProgramUniform1i,
-    ProgramUniform2i,
-    ProgramUniform3i,
-    ProgramUniform4i,
-    ProgramUniform1ui,
-    ProgramUniform2ui,
-    ProgramUniform3ui,
-    ProgramUniform4ui,
-    ProgramUniform1f,
-    ProgramUniform2f,
-    ProgramUniform3f,
-    ProgramUniform4f,
-    ProgramUniform1iv,
-    ProgramUniform2iv,
-    ProgramUniform3iv,
-    ProgramUniform4iv,
-    ProgramUniform1uiv,
-    ProgramUniform2uiv,
-    ProgramUniform3uiv,
-    ProgramUniform4uiv,
-    ProgramUniform1fv,
-    ProgramUniform2fv,
-    ProgramUniform3fv,
-    ProgramUniform4fv,
-    ProgramUniformMatrix2fv,
-    ProgramUniformMatrix3fv,
-    ProgramUniformMatrix4fv,
-    ProgramUniformMatrix2x3fv,
-    ProgramUniformMatrix3x2fv,
-    ProgramUniformMatrix2x4fv,
-    ProgramUniformMatrix4x2fv,
-    ProgramUniformMatrix3x4fv,
-    ProgramUniformMatrix4x3fv,
-    ValidateProgramPipeline,
-    GetProgramPipelineInfoLog,
-    BindImageTexture,
-    GetBooleani_v,
-    MemoryBarrier,
-    MemoryBarrierByRegion,
-    TexStorage2DMultisample,
-    GetMultisamplefv,
-    SampleMaski,
-    GetTexLevelParameteriv,
-    GetTexLevelParameterfv,
-    BindVertexBuffer,
-    VertexAttribFormat,
     VertexAttribIFormat,
-    VertexAttribBinding,
+    VertexAttribIPointer,
+    VertexAttribPointer,
     VertexBindingDivisor,
+    Viewport,
+    WaitSync,
     DrawElementsInstancedANGLE
 };
 }  // namespace gl

src/libANGLE/renderer/gl/DispatchTableGL_autogen.h

@@ -731,7 +731,7 @@ class DispatchTableGL : angle::NonCopyable
     PFNGLBLENDBARRIERPROC blendBarrier                 = nullptr;
     PFNGLPRIMITIVEBOUNDINGBOXPROC primitiveBoundingBox = nullptr;
 
-    // EXT_debug_marker
+    // GL_EXT_debug_marker
     PFNGLINSERTEVENTMARKEREXTPROC insertEventMarkerEXT = nullptr;
     PFNGLPOPGROUPMARKEREXTPROC popGroupMarkerEXT       = nullptr;
     PFNGLPUSHGROUPMARKEREXTPROC pushGroupMarkerEXT     = nullptr;

src/libGLESv2/entry_points_gles_2_0_autogen.cpp

@@ -922,22 +922,6 @@ void GL_APIENTRY GenBuffers(GLsizei n, GLuint *buffers)
     }
 }
 
-void GL_APIENTRY GenerateMipmap(GLenum target)
-{
-    EVENT("(GLenum target = 0x%X)", target);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::GenerateMipmap>(target);
-
-        if (context->skipValidation() || ValidateGenerateMipmap(context, target))
-        {
-            context->generateMipmap(target);
-        }
-    }
-}
-
 void GL_APIENTRY GenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
     EVENT("(GLsizei n = %d, GLuint *framebuffers = 0x%0.8p)", n, framebuffers);
@@ -986,6 +970,22 @@ void GL_APIENTRY GenTextures(GLsizei n, GLuint *textures)
     }
 }
 
+void GL_APIENTRY GenerateMipmap(GLenum target)
+{
+    EVENT("(GLenum target = 0x%X)", target);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::GenerateMipmap>(target);
+
+        if (context->skipValidation() || ValidateGenerateMipmap(context, target))
+        {
+            context->generateMipmap(target);
+        }
+    }
+}
+
 void GL_APIENTRY GetActiveAttrib(GLuint program,
                                  GLuint index,
                                  GLsizei bufSize,
@@ -1190,23 +1190,6 @@ void GL_APIENTRY GetIntegerv(GLenum pname, GLint *data)
     }
 }
 
-void GL_APIENTRY GetProgramiv(GLuint program, GLenum pname, GLint *params)
-{
-    EVENT("(GLuint program = %u, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", program, pname,
-          params);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::GetProgramiv>(program, pname, params);
-
-        if (context->skipValidation() || ValidateGetProgramiv(context, program, pname, params))
-        {
-            context->getProgramiv(program, pname, params);
-        }
-    }
-}
-
 void GL_APIENTRY GetProgramInfoLog(GLuint program,
                                    GLsizei bufSize,
                                    GLsizei *length,
@@ -1230,37 +1213,37 @@ void GL_APIENTRY GetProgramInfoLog(GLuint program,
     }
 }
 
-void GL_APIENTRY GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
+void GL_APIENTRY GetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", target, pname,
+    EVENT("(GLuint program = %u, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", program, pname,
           params);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::GetRenderbufferParameteriv>(target, pname, params);
+        context->gatherParams<EntryPoint::GetProgramiv>(program, pname, params);
 
-        if (context->skipValidation() ||
-            ValidateGetRenderbufferParameteriv(context, target, pname, params))
+        if (context->skipValidation() || ValidateGetProgramiv(context, program, pname, params))
         {
-            context->getRenderbufferParameteriv(target, pname, params);
+            context->getProgramiv(program, pname, params);
         }
     }
 }
 
-void GL_APIENTRY GetShaderiv(GLuint shader, GLenum pname, GLint *params)
+void GL_APIENTRY GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    EVENT("(GLuint shader = %u, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", shader, pname,
+    EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", target, pname,
           params);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::GetShaderiv>(shader, pname, params);
+        context->gatherParams<EntryPoint::GetRenderbufferParameteriv>(target, pname, params);
 
-        if (context->skipValidation() || ValidateGetShaderiv(context, shader, pname, params))
+        if (context->skipValidation() ||
+            ValidateGetRenderbufferParameteriv(context, target, pname, params))
         {
-            context->getShaderiv(shader, pname, params);
+            context->getRenderbufferParameteriv(target, pname, params);
         }
     }
 }
@@ -1329,6 +1312,23 @@ void GL_APIENTRY GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length
     }
 }
 
+void GL_APIENTRY GetShaderiv(GLuint shader, GLenum pname, GLint *params)
+{
+    EVENT("(GLuint shader = %u, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", shader, pname,
+          params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::GetShaderiv>(shader, pname, params);
+
+        if (context->skipValidation() || ValidateGetShaderiv(context, shader, pname, params))
+        {
+            context->getShaderiv(shader, pname, params);
+        }
+    }
+}
+
 const GLubyte *GL_APIENTRY GetString(GLenum name)
 {
     EVENT("(GLenum name = 0x%X)", name);
@@ -1381,6 +1381,24 @@ void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint *params)
     }
 }
 
+GLint GL_APIENTRY GetUniformLocation(GLuint program, const GLchar *name)
+{
+    EVENT("(GLuint program = %u, const GLchar *name = 0x%0.8p)", program, name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::GetUniformLocation>(program, name);
+
+        if (context->skipValidation() || ValidateGetUniformLocation(context, program, name))
+        {
+            return context->getUniformLocation(program, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetUniformLocation, GLint>();
+}
+
 void GL_APIENTRY GetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
     EVENT("(GLuint program = %u, GLint location = %d, GLfloat *params = 0x%0.8p)", program,
@@ -1415,22 +1433,22 @@ void GL_APIENTRY GetUniformiv(GLuint program, GLint location, GLint *params)
     }
 }
 
-GLint GL_APIENTRY GetUniformLocation(GLuint program, const GLchar *name)
+void GL_APIENTRY GetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
 {
-    EVENT("(GLuint program = %u, const GLchar *name = 0x%0.8p)", program, name);
+    EVENT("(GLuint index = %u, GLenum pname = 0x%X, void **pointer = 0x%0.8p)", index, pname,
+          pointer);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::GetUniformLocation>(program, name);
+        context->gatherParams<EntryPoint::GetVertexAttribPointerv>(index, pname, pointer);
 
-        if (context->skipValidation() || ValidateGetUniformLocation(context, program, name))
+        if (context->skipValidation() ||
+            ValidateGetVertexAttribPointerv(context, index, pname, pointer))
         {
-            return context->getUniformLocation(program, name);
+            context->getVertexAttribPointerv(index, pname, pointer);
         }
     }
-
-    return GetDefaultReturnValue<EntryPoint::GetUniformLocation, GLint>();
 }
 
 void GL_APIENTRY GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
@@ -1467,24 +1485,6 @@ void GL_APIENTRY GetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
     }
 }
 
-void GL_APIENTRY GetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
-{
-    EVENT("(GLuint index = %u, GLenum pname = 0x%X, void **pointer = 0x%0.8p)", index, pname,
-          pointer);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::GetVertexAttribPointerv>(index, pname, pointer);
-
-        if (context->skipValidation() ||
-            ValidateGetVertexAttribPointerv(context, index, pname, pointer))
-        {
-            context->getVertexAttribPointerv(index, pname, pointer);
-        }
-    }
-}
-
 void GL_APIENTRY Hint(GLenum target, GLenum mode)
 {
     EVENT("(GLenum target = 0x%X, GLenum mode = 0x%X)", target, mode);

src/libGLESv2/entry_points_gles_2_0_autogen.h

@@ -117,10 +117,10 @@ ANGLE_EXPORT void GL_APIENTRY FramebufferTexture2D(GLenum target,
                                                    GLint level);
 ANGLE_EXPORT void GL_APIENTRY FrontFace(GLenum mode);
 ANGLE_EXPORT void GL_APIENTRY GenBuffers(GLsizei n, GLuint *buffers);
-ANGLE_EXPORT void GL_APIENTRY GenerateMipmap(GLenum target);
 ANGLE_EXPORT void GL_APIENTRY GenFramebuffers(GLsizei n, GLuint *framebuffers);
 ANGLE_EXPORT void GL_APIENTRY GenRenderbuffers(GLsizei n, GLuint *renderbuffers);
 ANGLE_EXPORT void GL_APIENTRY GenTextures(GLsizei n, GLuint *textures);
+ANGLE_EXPORT void GL_APIENTRY GenerateMipmap(GLenum target);
 ANGLE_EXPORT void GL_APIENTRY GetActiveAttrib(GLuint program,
                                               GLuint index,
                                               GLsizei bufSize,
@@ -149,15 +149,14 @@ ANGLE_EXPORT void GL_APIENTRY GetFramebufferAttachmentParameteriv(GLenum target,
                                                                   GLenum pname,
                                                                   GLint *params);
 ANGLE_EXPORT void GL_APIENTRY GetIntegerv(GLenum pname, GLint *data);
-ANGLE_EXPORT void GL_APIENTRY GetProgramiv(GLuint program, GLenum pname, GLint *params);
 ANGLE_EXPORT void GL_APIENTRY GetProgramInfoLog(GLuint program,
                                                 GLsizei bufSize,
                                                 GLsizei *length,
                                                 GLchar *infoLog);
+ANGLE_EXPORT void GL_APIENTRY GetProgramiv(GLuint program, GLenum pname, GLint *params);
 ANGLE_EXPORT void GL_APIENTRY GetRenderbufferParameteriv(GLenum target,
                                                          GLenum pname,
                                                          GLint *params);
-ANGLE_EXPORT void GL_APIENTRY GetShaderiv(GLuint shader, GLenum pname, GLint *params);
 ANGLE_EXPORT void GL_APIENTRY GetShaderInfoLog(GLuint shader,
                                                GLsizei bufSize,
                                                GLsizei *length,
@@ -170,15 +169,16 @@ ANGLE_EXPORT void GL_APIENTRY GetShaderSource(GLuint shader,
                                               GLsizei bufSize,
                                               GLsizei *length,
                                               GLchar *source);
+ANGLE_EXPORT void GL_APIENTRY GetShaderiv(GLuint shader, GLenum pname, GLint *params);
 ANGLE_EXPORT const GLubyte *GL_APIENTRY GetString(GLenum name);
 ANGLE_EXPORT void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);
 ANGLE_EXPORT void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint *params);
+ANGLE_EXPORT GLint GL_APIENTRY GetUniformLocation(GLuint program, const GLchar *name);
 ANGLE_EXPORT void GL_APIENTRY GetUniformfv(GLuint program, GLint location, GLfloat *params);
 ANGLE_EXPORT void GL_APIENTRY GetUniformiv(GLuint program, GLint location, GLint *params);
-ANGLE_EXPORT GLint GL_APIENTRY GetUniformLocation(GLuint program, const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer);
 ANGLE_EXPORT void GL_APIENTRY GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params);
 ANGLE_EXPORT void GL_APIENTRY GetVertexAttribiv(GLuint index, GLenum pname, GLint *params);
-ANGLE_EXPORT void GL_APIENTRY GetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer);
 ANGLE_EXPORT void GL_APIENTRY Hint(GLenum target, GLenum mode);
 ANGLE_EXPORT GLboolean GL_APIENTRY IsBuffer(GLuint buffer);
 ANGLE_EXPORT GLboolean GL_APIENTRY IsEnabled(GLenum cap);

src/libGLESv2/entry_points_gles_3_0_autogen.h

@@ -16,43 +16,32 @@
 
 namespace gl
 {
-ANGLE_EXPORT void GL_APIENTRY ReadBuffer(GLenum src);
-ANGLE_EXPORT void GL_APIENTRY DrawRangeElements(GLenum mode,
-                                                GLuint start,
-                                                GLuint end,
-                                                GLsizei count,
-                                                GLenum type,
-                                                const void *indices);
-ANGLE_EXPORT void GL_APIENTRY TexImage3D(GLenum target,
-                                         GLint level,
-                                         GLint internalformat,
-                                         GLsizei width,
-                                         GLsizei height,
-                                         GLsizei depth,
-                                         GLint border,
-                                         GLenum format,
-                                         GLenum type,
-                                         const void *pixels);
-ANGLE_EXPORT void GL_APIENTRY TexSubImage3D(GLenum target,
-                                            GLint level,
-                                            GLint xoffset,
-                                            GLint yoffset,
-                                            GLint zoffset,
-                                            GLsizei width,
-                                            GLsizei height,
-                                            GLsizei depth,
-                                            GLenum format,
-                                            GLenum type,
-                                            const void *pixels);
-ANGLE_EXPORT void GL_APIENTRY CopyTexSubImage3D(GLenum target,
-                                                GLint level,
-                                                GLint xoffset,
-                                                GLint yoffset,
-                                                GLint zoffset,
-                                                GLint x,
-                                                GLint y,
-                                                GLsizei width,
-                                                GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY BeginQuery(GLenum target, GLuint id);
+ANGLE_EXPORT void GL_APIENTRY BeginTransformFeedback(GLenum primitiveMode);
+ANGLE_EXPORT void GL_APIENTRY BindBufferBase(GLenum target, GLuint index, GLuint buffer);
+ANGLE_EXPORT void GL_APIENTRY
+BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
+ANGLE_EXPORT void GL_APIENTRY BindSampler(GLuint unit, GLuint sampler);
+ANGLE_EXPORT void GL_APIENTRY BindTransformFeedback(GLenum target, GLuint id);
+ANGLE_EXPORT void GL_APIENTRY BindVertexArray(GLuint array);
+ANGLE_EXPORT void GL_APIENTRY BlitFramebuffer(GLint srcX0,
+                                              GLint srcY0,
+                                              GLint srcX1,
+                                              GLint srcY1,
+                                              GLint dstX0,
+                                              GLint dstY0,
+                                              GLint dstX1,
+                                              GLint dstY1,
+                                              GLbitfield mask,
+                                              GLenum filter);
+ANGLE_EXPORT void GL_APIENTRY ClearBufferfi(GLenum buffer,
+                                            GLint drawbuffer,
+                                            GLfloat depth,
+                                            GLint stencil);
+ANGLE_EXPORT void GL_APIENTRY ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
+ANGLE_EXPORT GLenum GL_APIENTRY ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
 ANGLE_EXPORT void GL_APIENTRY CompressedTexImage3D(GLenum target,
                                                    GLint level,
                                                    GLenum internalformat,
@@ -73,189 +62,106 @@ ANGLE_EXPORT void GL_APIENTRY CompressedTexSubImage3D(GLenum target,
                                                       GLenum format,
                                                       GLsizei imageSize,
                                                       const void *data);
-ANGLE_EXPORT void GL_APIENTRY GenQueries(GLsizei n, GLuint *ids);
-ANGLE_EXPORT void GL_APIENTRY DeleteQueries(GLsizei n, const GLuint *ids);
-ANGLE_EXPORT GLboolean GL_APIENTRY IsQuery(GLuint id);
-ANGLE_EXPORT void GL_APIENTRY BeginQuery(GLenum target, GLuint id);
-ANGLE_EXPORT void GL_APIENTRY EndQuery(GLenum target);
-ANGLE_EXPORT void GL_APIENTRY GetQueryiv(GLenum target, GLenum pname, GLint *params);
-ANGLE_EXPORT void GL_APIENTRY GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
-ANGLE_EXPORT GLboolean GL_APIENTRY UnmapBuffer(GLenum target);
-ANGLE_EXPORT void GL_APIENTRY GetBufferPointerv(GLenum target, GLenum pname, void **params);
-ANGLE_EXPORT void GL_APIENTRY DrawBuffers(GLsizei n, const GLenum *bufs);
-ANGLE_EXPORT void GL_APIENTRY UniformMatrix2x3fv(GLint location,
-                                                 GLsizei count,
-                                                 GLboolean transpose,
-                                                 const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY UniformMatrix3x2fv(GLint location,
-                                                 GLsizei count,
-                                                 GLboolean transpose,
-                                                 const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY UniformMatrix2x4fv(GLint location,
-                                                 GLsizei count,
-                                                 GLboolean transpose,
-                                                 const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY UniformMatrix4x2fv(GLint location,
-                                                 GLsizei count,
-                                                 GLboolean transpose,
-                                                 const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY UniformMatrix3x4fv(GLint location,
-                                                 GLsizei count,
-                                                 GLboolean transpose,
-                                                 const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY UniformMatrix4x3fv(GLint location,
-                                                 GLsizei count,
-                                                 GLboolean transpose,
-                                                 const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY BlitFramebuffer(GLint srcX0,
-                                              GLint srcY0,
-                                              GLint srcX1,
-                                              GLint srcY1,
-                                              GLint dstX0,
-                                              GLint dstY0,
-                                              GLint dstX1,
-                                              GLint dstY1,
-                                              GLbitfield mask,
-                                              GLenum filter);
-ANGLE_EXPORT void GL_APIENTRY RenderbufferStorageMultisample(GLenum target,
-                                                             GLsizei samples,
-                                                             GLenum internalformat,
-                                                             GLsizei width,
-                                                             GLsizei height);
-ANGLE_EXPORT void GL_APIENTRY
-FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-ANGLE_EXPORT void *GL_APIENTRY MapBufferRange(GLenum target,
-                                              GLintptr offset,
-                                              GLsizeiptr length,
-                                              GLbitfield access);
-ANGLE_EXPORT void GL_APIENTRY FlushMappedBufferRange(GLenum target,
-                                                     GLintptr offset,
-                                                     GLsizeiptr length);
-ANGLE_EXPORT void GL_APIENTRY BindVertexArray(GLuint array);
-ANGLE_EXPORT void GL_APIENTRY DeleteVertexArrays(GLsizei n, const GLuint *arrays);
-ANGLE_EXPORT void GL_APIENTRY GenVertexArrays(GLsizei n, GLuint *arrays);
-ANGLE_EXPORT GLboolean GL_APIENTRY IsVertexArray(GLuint array);
-ANGLE_EXPORT void GL_APIENTRY GetIntegeri_v(GLenum target, GLuint index, GLint *data);
-ANGLE_EXPORT void GL_APIENTRY BeginTransformFeedback(GLenum primitiveMode);
-ANGLE_EXPORT void GL_APIENTRY EndTransformFeedback();
-ANGLE_EXPORT void GL_APIENTRY
-BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-ANGLE_EXPORT void GL_APIENTRY BindBufferBase(GLenum target, GLuint index, GLuint buffer);
-ANGLE_EXPORT void GL_APIENTRY TransformFeedbackVaryings(GLuint program,
-                                                        GLsizei count,
-                                                        const GLchar *const *varyings,
-                                                        GLenum bufferMode);
-ANGLE_EXPORT void GL_APIENTRY GetTransformFeedbackVarying(GLuint program,
-                                                          GLuint index,
-                                                          GLsizei bufSize,
-                                                          GLsizei *length,
-                                                          GLsizei *size,
-                                                          GLenum *type,
-                                                          GLchar *name);
-ANGLE_EXPORT void GL_APIENTRY
-VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
-ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
-ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
-ANGLE_EXPORT void GL_APIENTRY VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
-ANGLE_EXPORT void GL_APIENTRY
-VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-ANGLE_EXPORT void GL_APIENTRY VertexAttribI4iv(GLuint index, const GLint *v);
-ANGLE_EXPORT void GL_APIENTRY VertexAttribI4uiv(GLuint index, const GLuint *v);
-ANGLE_EXPORT void GL_APIENTRY GetUniformuiv(GLuint program, GLint location, GLuint *params);
-ANGLE_EXPORT GLint GL_APIENTRY GetFragDataLocation(GLuint program, const GLchar *name);
-ANGLE_EXPORT void GL_APIENTRY Uniform1ui(GLint location, GLuint v0);
-ANGLE_EXPORT void GL_APIENTRY Uniform2ui(GLint location, GLuint v0, GLuint v1);
-ANGLE_EXPORT void GL_APIENTRY Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
-ANGLE_EXPORT void GL_APIENTRY
-Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-ANGLE_EXPORT void GL_APIENTRY Uniform1uiv(GLint location, GLsizei count, const GLuint *value);
-ANGLE_EXPORT void GL_APIENTRY Uniform2uiv(GLint location, GLsizei count, const GLuint *value);
-ANGLE_EXPORT void GL_APIENTRY Uniform3uiv(GLint location, GLsizei count, const GLuint *value);
-ANGLE_EXPORT void GL_APIENTRY Uniform4uiv(GLint location, GLsizei count, const GLuint *value);
-ANGLE_EXPORT void GL_APIENTRY ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value);
-ANGLE_EXPORT void GL_APIENTRY ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value);
-ANGLE_EXPORT void GL_APIENTRY ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY ClearBufferfi(GLenum buffer,
-                                            GLint drawbuffer,
-                                            GLfloat depth,
-                                            GLint stencil);
-ANGLE_EXPORT const GLubyte *GL_APIENTRY GetStringi(GLenum name, GLuint index);
 ANGLE_EXPORT void GL_APIENTRY CopyBufferSubData(GLenum readTarget,
                                                 GLenum writeTarget,
                                                 GLintptr readOffset,
                                                 GLintptr writeOffset,
                                                 GLsizeiptr size);
-ANGLE_EXPORT void GL_APIENTRY GetUniformIndices(GLuint program,
-                                                GLsizei uniformCount,
-                                                const GLchar *const *uniformNames,
-                                                GLuint *uniformIndices);
-ANGLE_EXPORT void GL_APIENTRY GetActiveUniformsiv(GLuint program,
-                                                  GLsizei uniformCount,
-                                                  const GLuint *uniformIndices,
-                                                  GLenum pname,
-                                                  GLint *params);
-ANGLE_EXPORT GLuint GL_APIENTRY GetUniformBlockIndex(GLuint program,
-                                                     const GLchar *uniformBlockName);
-ANGLE_EXPORT void GL_APIENTRY GetActiveUniformBlockiv(GLuint program,
-                                                      GLuint uniformBlockIndex,
-                                                      GLenum pname,
-                                                      GLint *params);
-ANGLE_EXPORT void GL_APIENTRY GetActiveUniformBlockName(GLuint program,
-                                                        GLuint uniformBlockIndex,
-                                                        GLsizei bufSize,
-                                                        GLsizei *length,
-                                                        GLchar *uniformBlockName);
-ANGLE_EXPORT void GL_APIENTRY UniformBlockBinding(GLuint program,
-                                                  GLuint uniformBlockIndex,
-                                                  GLuint uniformBlockBinding);
+ANGLE_EXPORT void GL_APIENTRY CopyTexSubImage3D(GLenum target,
+                                                GLint level,
+                                                GLint xoffset,
+                                                GLint yoffset,
+                                                GLint zoffset,
+                                                GLint x,
+                                                GLint y,
+                                                GLsizei width,
+                                                GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY DeleteQueries(GLsizei n, const GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY DeleteSamplers(GLsizei count, const GLuint *samplers);
+ANGLE_EXPORT void GL_APIENTRY DeleteSync(GLsync sync);
+ANGLE_EXPORT void GL_APIENTRY DeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
+ANGLE_EXPORT void GL_APIENTRY DeleteVertexArrays(GLsizei n, const GLuint *arrays);
 ANGLE_EXPORT void GL_APIENTRY DrawArraysInstanced(GLenum mode,
                                                   GLint first,
                                                   GLsizei count,
                                                   GLsizei instancecount);
+ANGLE_EXPORT void GL_APIENTRY DrawBuffers(GLsizei n, const GLenum *bufs);
 ANGLE_EXPORT void GL_APIENTRY DrawElementsInstanced(GLenum mode,
                                                     GLsizei count,
                                                     GLenum type,
                                                     const void *indices,
                                                     GLsizei instancecount);
+ANGLE_EXPORT void GL_APIENTRY DrawRangeElements(GLenum mode,
+                                                GLuint start,
+                                                GLuint end,
+                                                GLsizei count,
+                                                GLenum type,
+                                                const void *indices);
+ANGLE_EXPORT void GL_APIENTRY EndQuery(GLenum target);
+ANGLE_EXPORT void GL_APIENTRY EndTransformFeedback();
 ANGLE_EXPORT GLsync GL_APIENTRY FenceSync(GLenum condition, GLbitfield flags);
-ANGLE_EXPORT GLboolean GL_APIENTRY IsSync(GLsync sync);
-ANGLE_EXPORT void GL_APIENTRY DeleteSync(GLsync sync);
-ANGLE_EXPORT GLenum GL_APIENTRY ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-ANGLE_EXPORT void GL_APIENTRY WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
-ANGLE_EXPORT void GL_APIENTRY GetInteger64v(GLenum pname, GLint64 *data);
+ANGLE_EXPORT void GL_APIENTRY FlushMappedBufferRange(GLenum target,
+                                                     GLintptr offset,
+                                                     GLsizeiptr length);
 ANGLE_EXPORT void GL_APIENTRY
-GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-ANGLE_EXPORT void GL_APIENTRY GetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
-ANGLE_EXPORT void GL_APIENTRY GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
+FramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
+ANGLE_EXPORT void GL_APIENTRY GenQueries(GLsizei n, GLuint *ids);
 ANGLE_EXPORT void GL_APIENTRY GenSamplers(GLsizei count, GLuint *samplers);
-ANGLE_EXPORT void GL_APIENTRY DeleteSamplers(GLsizei count, const GLuint *samplers);
-ANGLE_EXPORT GLboolean GL_APIENTRY IsSampler(GLuint sampler);
-ANGLE_EXPORT void GL_APIENTRY BindSampler(GLuint unit, GLuint sampler);
-ANGLE_EXPORT void GL_APIENTRY SamplerParameteri(GLuint sampler, GLenum pname, GLint param);
-ANGLE_EXPORT void GL_APIENTRY SamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
-ANGLE_EXPORT void GL_APIENTRY SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
-ANGLE_EXPORT void GL_APIENTRY SamplerParameterfv(GLuint sampler,
-                                                 GLenum pname,
-                                                 const GLfloat *param);
-ANGLE_EXPORT void GL_APIENTRY GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
-ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
-ANGLE_EXPORT void GL_APIENTRY VertexAttribDivisor(GLuint index, GLuint divisor);
-ANGLE_EXPORT void GL_APIENTRY BindTransformFeedback(GLenum target, GLuint id);
-ANGLE_EXPORT void GL_APIENTRY DeleteTransformFeedbacks(GLsizei n, const GLuint *ids);
 ANGLE_EXPORT void GL_APIENTRY GenTransformFeedbacks(GLsizei n, GLuint *ids);
-ANGLE_EXPORT GLboolean GL_APIENTRY IsTransformFeedback(GLuint id);
-ANGLE_EXPORT void GL_APIENTRY PauseTransformFeedback();
-ANGLE_EXPORT void GL_APIENTRY ResumeTransformFeedback();
+ANGLE_EXPORT void GL_APIENTRY GenVertexArrays(GLsizei n, GLuint *arrays);
+ANGLE_EXPORT void GL_APIENTRY GetActiveUniformBlockName(GLuint program,
+                                                        GLuint uniformBlockIndex,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLchar *uniformBlockName);
+ANGLE_EXPORT void GL_APIENTRY GetActiveUniformBlockiv(GLuint program,
+                                                      GLuint uniformBlockIndex,
+                                                      GLenum pname,
+                                                      GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetActiveUniformsiv(GLuint program,
+                                                  GLsizei uniformCount,
+                                                  const GLuint *uniformIndices,
+                                                  GLenum pname,
+                                                  GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params);
+ANGLE_EXPORT void GL_APIENTRY GetBufferPointerv(GLenum target, GLenum pname, void **params);
+ANGLE_EXPORT GLint GL_APIENTRY GetFragDataLocation(GLuint program, const GLchar *name);
+ANGLE_EXPORT void GL_APIENTRY GetInteger64i_v(GLenum target, GLuint index, GLint64 *data);
+ANGLE_EXPORT void GL_APIENTRY GetInteger64v(GLenum pname, GLint64 *data);
+ANGLE_EXPORT void GL_APIENTRY GetIntegeri_v(GLenum target, GLuint index, GLint *data);
+ANGLE_EXPORT void GL_APIENTRY GetInternalformativ(GLenum target,
+                                                  GLenum internalformat,
+                                                  GLenum pname,
+                                                  GLsizei bufSize,
+                                                  GLint *params);
 ANGLE_EXPORT void GL_APIENTRY GetProgramBinary(GLuint program,
                                                GLsizei bufSize,
                                                GLsizei *length,
                                                GLenum *binaryFormat,
                                                void *binary);
-ANGLE_EXPORT void GL_APIENTRY ProgramBinary(GLuint program,
-                                            GLenum binaryFormat,
-                                            const void *binary,
-                                            GLsizei length);
-ANGLE_EXPORT void GL_APIENTRY ProgramParameteri(GLuint program, GLenum pname, GLint value);
+ANGLE_EXPORT void GL_APIENTRY GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetQueryiv(GLenum target, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params);
+ANGLE_EXPORT const GLubyte *GL_APIENTRY GetStringi(GLenum name, GLuint index);
+ANGLE_EXPORT void GL_APIENTRY
+GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
+ANGLE_EXPORT void GL_APIENTRY GetTransformFeedbackVarying(GLuint program,
+                                                          GLuint index,
+                                                          GLsizei bufSize,
+                                                          GLsizei *length,
+                                                          GLsizei *size,
+                                                          GLenum *type,
+                                                          GLchar *name);
+ANGLE_EXPORT GLuint GL_APIENTRY GetUniformBlockIndex(GLuint program,
+                                                     const GLchar *uniformBlockName);
+ANGLE_EXPORT void GL_APIENTRY GetUniformIndices(GLuint program,
+                                                GLsizei uniformCount,
+                                                const GLchar *const *uniformNames,
+                                                GLuint *uniformIndices);
+ANGLE_EXPORT void GL_APIENTRY GetUniformuiv(GLuint program, GLint location, GLuint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params);
 ANGLE_EXPORT void GL_APIENTRY InvalidateFramebuffer(GLenum target,
                                                     GLsizei numAttachments,
                                                     const GLenum *attachments);
@@ -266,6 +172,44 @@ ANGLE_EXPORT void GL_APIENTRY InvalidateSubFramebuffer(GLenum target,
                                                        GLint y,
                                                        GLsizei width,
                                                        GLsizei height);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsQuery(GLuint id);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsSampler(GLuint sampler);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsSync(GLsync sync);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsTransformFeedback(GLuint id);
+ANGLE_EXPORT GLboolean GL_APIENTRY IsVertexArray(GLuint array);
+ANGLE_EXPORT void *GL_APIENTRY MapBufferRange(GLenum target,
+                                              GLintptr offset,
+                                              GLsizeiptr length,
+                                              GLbitfield access);
+ANGLE_EXPORT void GL_APIENTRY PauseTransformFeedback();
+ANGLE_EXPORT void GL_APIENTRY ProgramBinary(GLuint program,
+                                            GLenum binaryFormat,
+                                            const void *binary,
+                                            GLsizei length);
+ANGLE_EXPORT void GL_APIENTRY ProgramParameteri(GLuint program, GLenum pname, GLint value);
+ANGLE_EXPORT void GL_APIENTRY ReadBuffer(GLenum src);
+ANGLE_EXPORT void GL_APIENTRY RenderbufferStorageMultisample(GLenum target,
+                                                             GLsizei samples,
+                                                             GLenum internalformat,
+                                                             GLsizei width,
+                                                             GLsizei height);
+ANGLE_EXPORT void GL_APIENTRY ResumeTransformFeedback();
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameterfv(GLuint sampler,
+                                                 GLenum pname,
+                                                 const GLfloat *param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameteri(GLuint sampler, GLenum pname, GLint param);
+ANGLE_EXPORT void GL_APIENTRY SamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param);
+ANGLE_EXPORT void GL_APIENTRY TexImage3D(GLenum target,
+                                         GLint level,
+                                         GLint internalformat,
+                                         GLsizei width,
+                                         GLsizei height,
+                                         GLsizei depth,
+                                         GLint border,
+                                         GLenum format,
+                                         GLenum type,
+                                         const void *pixels);
 ANGLE_EXPORT void GL_APIENTRY
 TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
 ANGLE_EXPORT void GL_APIENTRY TexStorage3D(GLenum target,
@@ -274,11 +218,67 @@ ANGLE_EXPORT void GL_APIENTRY TexStorage3D(GLenum target,
                                            GLsizei width,
                                            GLsizei height,
                                            GLsizei depth);
-ANGLE_EXPORT void GL_APIENTRY GetInternalformativ(GLenum target,
-                                                  GLenum internalformat,
-                                                  GLenum pname,
-                                                  GLsizei bufSize,
-                                                  GLint *params);
+ANGLE_EXPORT void GL_APIENTRY TexSubImage3D(GLenum target,
+                                            GLint level,
+                                            GLint xoffset,
+                                            GLint yoffset,
+                                            GLint zoffset,
+                                            GLsizei width,
+                                            GLsizei height,
+                                            GLsizei depth,
+                                            GLenum format,
+                                            GLenum type,
+                                            const void *pixels);
+ANGLE_EXPORT void GL_APIENTRY TransformFeedbackVaryings(GLuint program,
+                                                        GLsizei count,
+                                                        const GLchar *const *varyings,
+                                                        GLenum bufferMode);
+ANGLE_EXPORT void GL_APIENTRY Uniform1ui(GLint location, GLuint v0);
+ANGLE_EXPORT void GL_APIENTRY Uniform1uiv(GLint location, GLsizei count, const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform2ui(GLint location, GLuint v0, GLuint v1);
+ANGLE_EXPORT void GL_APIENTRY Uniform2uiv(GLint location, GLsizei count, const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2);
+ANGLE_EXPORT void GL_APIENTRY Uniform3uiv(GLint location, GLsizei count, const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY
+Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+ANGLE_EXPORT void GL_APIENTRY Uniform4uiv(GLint location, GLsizei count, const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY UniformBlockBinding(GLuint program,
+                                                  GLuint uniformBlockIndex,
+                                                  GLuint uniformBlockBinding);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix2x3fv(GLint location,
+                                                 GLsizei count,
+                                                 GLboolean transpose,
+                                                 const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix2x4fv(GLint location,
+                                                 GLsizei count,
+                                                 GLboolean transpose,
+                                                 const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix3x2fv(GLint location,
+                                                 GLsizei count,
+                                                 GLboolean transpose,
+                                                 const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix3x4fv(GLint location,
+                                                 GLsizei count,
+                                                 GLboolean transpose,
+                                                 const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix4x2fv(GLint location,
+                                                 GLsizei count,
+                                                 GLboolean transpose,
+                                                 const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY UniformMatrix4x3fv(GLint location,
+                                                 GLsizei count,
+                                                 GLboolean transpose,
+                                                 const GLfloat *value);
+ANGLE_EXPORT GLboolean GL_APIENTRY UnmapBuffer(GLenum target);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribDivisor(GLuint index, GLuint divisor);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribI4iv(GLuint index, const GLint *v);
+ANGLE_EXPORT void GL_APIENTRY
+VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribI4uiv(GLuint index, const GLuint *v);
+ANGLE_EXPORT void GL_APIENTRY
+VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
+ANGLE_EXPORT void GL_APIENTRY WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout);
 }  // namespace gl
 
 #endif  // LIBGLESV2_ENTRYPOINTSGLES30_AUTOGEN_H_

src/libGLESv2/entry_points_gles_3_1_autogen.cpp

@@ -14,6 +14,123 @@
 
 namespace gl
 {
+void GL_APIENTRY ActiveShaderProgram(GLuint pipeline, GLuint program)
+{
+    EVENT("(GLuint pipeline = %u, GLuint program = %u)", pipeline, program);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::ActiveShaderProgram>(pipeline, program);
+
+        if (context->skipValidation() || ValidateActiveShaderProgram(context, pipeline, program))
+        {
+            context->activeShaderProgram(pipeline, program);
+        }
+    }
+}
+
+void GL_APIENTRY BindImageTexture(GLuint unit,
+                                  GLuint texture,
+                                  GLint level,
+                                  GLboolean layered,
+                                  GLint layer,
+                                  GLenum access,
+                                  GLenum format)
+{
+    EVENT(
+        "(GLuint unit = %u, GLuint texture = %u, GLint level = %d, GLboolean layered = %u, GLint "
+        "layer = %d, GLenum access = 0x%X, GLenum format = 0x%X)",
+        unit, texture, level, layered, layer, access, format);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::BindImageTexture>(unit, texture, level, layered, layer,
+                                                            access, format);
+
+        if (context->skipValidation() ||
+            ValidateBindImageTexture(context, unit, texture, level, layered, layer, access, format))
+        {
+            context->bindImageTexture(unit, texture, level, layered, layer, access, format);
+        }
+    }
+}
+
+void GL_APIENTRY BindProgramPipeline(GLuint pipeline)
+{
+    EVENT("(GLuint pipeline = %u)", pipeline);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::BindProgramPipeline>(pipeline);
+
+        if (context->skipValidation() || ValidateBindProgramPipeline(context, pipeline))
+        {
+            context->bindProgramPipeline(pipeline);
+        }
+    }
+}
+
+void GL_APIENTRY BindVertexBuffer(GLuint bindingindex,
+                                  GLuint buffer,
+                                  GLintptr offset,
+                                  GLsizei stride)
+{
+    EVENT(
+        "(GLuint bindingindex = %u, GLuint buffer = %u, GLintptr offset = %d, GLsizei stride = %d)",
+        bindingindex, buffer, offset, stride);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::BindVertexBuffer>(bindingindex, buffer, offset, stride);
+
+        if (context->skipValidation() ||
+            ValidateBindVertexBuffer(context, bindingindex, buffer, offset, stride))
+        {
+            context->bindVertexBuffer(bindingindex, buffer, offset, stride);
+        }
+    }
+}
+
+GLuint GL_APIENTRY CreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
+{
+    EVENT("(GLenum type = 0x%X, GLsizei count = %d, const GLchar *const*strings = 0x%0.8p)", type,
+          count, strings);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::CreateShaderProgramv>(type, count, strings);
+
+        if (context->skipValidation() ||
+            ValidateCreateShaderProgramv(context, type, count, strings))
+        {
+            return context->createShaderProgramv(type, count, strings);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::CreateShaderProgramv, GLuint>();
+}
+
+void GL_APIENTRY DeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
+{
+    EVENT("(GLsizei n = %d, const GLuint *pipelines = 0x%0.8p)", n, pipelines);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::DeleteProgramPipelines>(n, pipelines);
+
+        if (context->skipValidation() || ValidateDeleteProgramPipelines(context, n, pipelines))
+        {
+            context->deleteProgramPipelines(n, pipelines);
+        }
+    }
+}
+
 void GL_APIENTRY DispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
 {
     EVENT("(GLuint num_groups_x = %u, GLuint num_groups_y = %u, GLuint num_groups_z = %u)",
@@ -100,6 +217,39 @@ void GL_APIENTRY FramebufferParameteri(GLenum target, GLenum pname, GLint param)
     }
 }
 
+void GL_APIENTRY GenProgramPipelines(GLsizei n, GLuint *pipelines)
+{
+    EVENT("(GLsizei n = %d, GLuint *pipelines = 0x%0.8p)", n, pipelines);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::GenProgramPipelines>(n, pipelines);
+
+        if (context->skipValidation() || ValidateGenProgramPipelines(context, n, pipelines))
+        {
+            context->genProgramPipelines(n, pipelines);
+        }
+    }
+}
+
+void GL_APIENTRY GetBooleani_v(GLenum target, GLuint index, GLboolean *data)
+{
+    EVENT("(GLenum target = 0x%X, GLuint index = %u, GLboolean *data = 0x%0.8p)", target, index,
+          data);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::GetBooleani_v>(target, index, data);
+
+        if (context->skipValidation() || ValidateGetBooleani_v(context, target, index, data))
+        {
+            context->getBooleani_v(target, index, data);
+        }
+    }
+}
+
 void GL_APIENTRY GetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
     EVENT("(GLenum target = 0x%X, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", target, pname,
@@ -118,6 +268,22 @@ void GL_APIENTRY GetFramebufferParameteriv(GLenum target, GLenum pname, GLint *p
     }
 }
 
+void GL_APIENTRY GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
+{
+    EVENT("(GLenum pname = 0x%X, GLuint index = %u, GLfloat *val = 0x%0.8p)", pname, index, val);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::GetMultisamplefv>(pname, index, val);
+
+        if (context->skipValidation() || ValidateGetMultisamplefv(context, pname, index, val))
+        {
+            context->getMultisamplefv(pname, index, val);
+        }
+    }
+}
+
 void GL_APIENTRY GetProgramInterfaceiv(GLuint program,
                                        GLenum programInterface,
                                        GLenum pname,
@@ -142,6 +308,48 @@ void GL_APIENTRY GetProgramInterfaceiv(GLuint program,
     }
 }
 
+void GL_APIENTRY GetProgramPipelineInfoLog(GLuint pipeline,
+                                           GLsizei bufSize,
+                                           GLsizei *length,
+                                           GLchar *infoLog)
+{
+    EVENT(
+        "(GLuint pipeline = %u, GLsizei bufSize = %d, GLsizei *length = 0x%0.8p, GLchar *infoLog = "
+        "0x%0.8p)",
+        pipeline, bufSize, length, infoLog);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::GetProgramPipelineInfoLog>(pipeline, bufSize, length,
+                                                                     infoLog);
+
+        if (context->skipValidation() ||
+            ValidateGetProgramPipelineInfoLog(context, pipeline, bufSize, length, infoLog))
+        {
+            context->getProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+        }
+    }
+}
+
+void GL_APIENTRY GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
+{
+    EVENT("(GLuint pipeline = %u, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", pipeline, pname,
+          params);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::GetProgramPipelineiv>(pipeline, pname, params);
+
+        if (context->skipValidation() ||
+            ValidateGetProgramPipelineiv(context, pipeline, pname, params))
+        {
+            context->getProgramPipelineiv(pipeline, pname, params);
+        }
+    }
+}
+
 GLuint GL_APIENTRY GetProgramResourceIndex(GLuint program,
                                            GLenum programInterface,
                                            const GLchar *name)
@@ -164,6 +372,29 @@ GLuint GL_APIENTRY GetProgramResourceIndex(GLuint program,
     return GetDefaultReturnValue<EntryPoint::GetProgramResourceIndex, GLuint>();
 }
 
+GLint GL_APIENTRY GetProgramResourceLocation(GLuint program,
+                                             GLenum programInterface,
+                                             const GLchar *name)
+{
+    EVENT("(GLuint program = %u, GLenum programInterface = 0x%X, const GLchar *name = 0x%0.8p)",
+          program, programInterface, name);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::GetProgramResourceLocation>(program, programInterface,
+                                                                      name);
+
+        if (context->skipValidation() ||
+            ValidateGetProgramResourceLocation(context, program, programInterface, name))
+        {
+            return context->getProgramResourceLocation(program, programInterface, name);
+        }
+    }
+
+    return GetDefaultReturnValue<EntryPoint::GetProgramResourceLocation, GLint>();
+}
+
 void GL_APIENTRY GetProgramResourceName(GLuint program,
                                         GLenum programInterface,
                                         GLuint index,
@@ -223,163 +454,128 @@ void GL_APIENTRY GetProgramResourceiv(GLuint program,
     }
 }
 
-GLint GL_APIENTRY GetProgramResourceLocation(GLuint program,
-                                             GLenum programInterface,
-                                             const GLchar *name)
-{
-    EVENT("(GLuint program = %u, GLenum programInterface = 0x%X, const GLchar *name = 0x%0.8p)",
-          program, programInterface, name);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::GetProgramResourceLocation>(program, programInterface,
-                                                                      name);
-
-        if (context->skipValidation() ||
-            ValidateGetProgramResourceLocation(context, program, programInterface, name))
-        {
-            return context->getProgramResourceLocation(program, programInterface, name);
-        }
-    }
-
-    return GetDefaultReturnValue<EntryPoint::GetProgramResourceLocation, GLint>();
-}
-
-void GL_APIENTRY UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
+void GL_APIENTRY GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    EVENT("(GLuint pipeline = %u, GLbitfield stages = 0x%X, GLuint program = %u)", pipeline, stages,
-          program);
+    EVENT(
+        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLfloat *params = 0x%0.8p)",
+        target, level, pname, params);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::UseProgramStages>(pipeline, stages, program);
+        context->gatherParams<EntryPoint::GetTexLevelParameterfv>(target, level, pname, params);
 
         if (context->skipValidation() ||
-            ValidateUseProgramStages(context, pipeline, stages, program))
-        {
-            context->useProgramStages(pipeline, stages, program);
-        }
-    }
-}
-
-void GL_APIENTRY ActiveShaderProgram(GLuint pipeline, GLuint program)
-{
-    EVENT("(GLuint pipeline = %u, GLuint program = %u)", pipeline, program);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::ActiveShaderProgram>(pipeline, program);
-
-        if (context->skipValidation() || ValidateActiveShaderProgram(context, pipeline, program))
+            ValidateGetTexLevelParameterfv(context, target, level, pname, params))
         {
-            context->activeShaderProgram(pipeline, program);
+            context->getTexLevelParameterfv(target, level, pname, params);
         }
     }
 }
 
-GLuint GL_APIENTRY CreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
+void GL_APIENTRY GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    EVENT("(GLenum type = 0x%X, GLsizei count = %d, const GLchar *const*strings = 0x%0.8p)", type,
-          count, strings);
+    EVENT("(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLint *params = 0x%0.8p)",
+          target, level, pname, params);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::CreateShaderProgramv>(type, count, strings);
+        context->gatherParams<EntryPoint::GetTexLevelParameteriv>(target, level, pname, params);
 
         if (context->skipValidation() ||
-            ValidateCreateShaderProgramv(context, type, count, strings))
+            ValidateGetTexLevelParameteriv(context, target, level, pname, params))
         {
-            return context->createShaderProgramv(type, count, strings);
+            context->getTexLevelParameteriv(target, level, pname, params);
         }
     }
-
-    return GetDefaultReturnValue<EntryPoint::CreateShaderProgramv, GLuint>();
 }
 
-void GL_APIENTRY BindProgramPipeline(GLuint pipeline)
+GLboolean GL_APIENTRY IsProgramPipeline(GLuint pipeline)
 {
     EVENT("(GLuint pipeline = %u)", pipeline);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::BindProgramPipeline>(pipeline);
+        context->gatherParams<EntryPoint::IsProgramPipeline>(pipeline);
 
-        if (context->skipValidation() || ValidateBindProgramPipeline(context, pipeline))
+        if (context->skipValidation() || ValidateIsProgramPipeline(context, pipeline))
         {
-            context->bindProgramPipeline(pipeline);
+            return context->isProgramPipeline(pipeline);
         }
     }
+
+    return GetDefaultReturnValue<EntryPoint::IsProgramPipeline, GLboolean>();
 }
 
-void GL_APIENTRY DeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
+void GL_APIENTRY MemoryBarrier(GLbitfield barriers)
 {
-    EVENT("(GLsizei n = %d, const GLuint *pipelines = 0x%0.8p)", n, pipelines);
+    EVENT("(GLbitfield barriers = 0x%X)", barriers);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::DeleteProgramPipelines>(n, pipelines);
+        context->gatherParams<EntryPoint::MemoryBarrier>(barriers);
 
-        if (context->skipValidation() || ValidateDeleteProgramPipelines(context, n, pipelines))
+        if (context->skipValidation() || ValidateMemoryBarrier(context, barriers))
         {
-            context->deleteProgramPipelines(n, pipelines);
+            context->memoryBarrier(barriers);
         }
     }
 }
 
-void GL_APIENTRY GenProgramPipelines(GLsizei n, GLuint *pipelines)
+void GL_APIENTRY MemoryBarrierByRegion(GLbitfield barriers)
 {
-    EVENT("(GLsizei n = %d, GLuint *pipelines = 0x%0.8p)", n, pipelines);
+    EVENT("(GLbitfield barriers = 0x%X)", barriers);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::GenProgramPipelines>(n, pipelines);
+        context->gatherParams<EntryPoint::MemoryBarrierByRegion>(barriers);
 
-        if (context->skipValidation() || ValidateGenProgramPipelines(context, n, pipelines))
+        if (context->skipValidation() || ValidateMemoryBarrierByRegion(context, barriers))
         {
-            context->genProgramPipelines(n, pipelines);
+            context->memoryBarrierByRegion(barriers);
         }
     }
 }
 
-GLboolean GL_APIENTRY IsProgramPipeline(GLuint pipeline)
+void GL_APIENTRY ProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 {
-    EVENT("(GLuint pipeline = %u)", pipeline);
+    EVENT("(GLuint program = %u, GLint location = %d, GLfloat v0 = %f)", program, location, v0);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::IsProgramPipeline>(pipeline);
+        context->gatherParams<EntryPoint::ProgramUniform1f>(program, location, v0);
 
-        if (context->skipValidation() || ValidateIsProgramPipeline(context, pipeline))
+        if (context->skipValidation() || ValidateProgramUniform1f(context, program, location, v0))
         {
-            return context->isProgramPipeline(pipeline);
+            context->programUniform1f(program, location, v0);
         }
     }
-
-    return GetDefaultReturnValue<EntryPoint::IsProgramPipeline, GLboolean>();
 }
 
-void GL_APIENTRY GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
+void GL_APIENTRY ProgramUniform1fv(GLuint program,
+                                   GLint location,
+                                   GLsizei count,
+                                   const GLfloat *value)
 {
-    EVENT("(GLuint pipeline = %u, GLenum pname = 0x%X, GLint *params = 0x%0.8p)", pipeline, pname,
-          params);
+    EVENT(
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
+        "0x%0.8p)",
+        program, location, count, value);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::GetProgramPipelineiv>(pipeline, pname, params);
+        context->gatherParams<EntryPoint::ProgramUniform1fv>(program, location, count, value);
 
         if (context->skipValidation() ||
-            ValidateGetProgramPipelineiv(context, pipeline, pname, params))
+            ValidateProgramUniform1fv(context, program, location, count, value))
         {
-            context->getProgramPipelineiv(pipeline, pname, params);
+            context->programUniform1fv(program, location, count, value);
         }
     }
 }
@@ -400,59 +596,25 @@ void GL_APIENTRY ProgramUniform1i(GLuint program, GLint location, GLint v0)
     }
 }
 
-void GL_APIENTRY ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
-    EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d)", program,
-          location, v0, v1);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::ProgramUniform2i>(program, location, v0, v1);
-
-        if (context->skipValidation() ||
-            ValidateProgramUniform2i(context, program, location, v0, v1))
-        {
-            context->programUniform2i(program, location, v0, v1);
-        }
-    }
-}
-
-void GL_APIENTRY ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
-    EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d)",
-          program, location, v0, v1, v2);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::ProgramUniform3i>(program, location, v0, v1, v2);
-
-        if (context->skipValidation() ||
-            ValidateProgramUniform3i(context, program, location, v0, v1, v2))
-        {
-            context->programUniform3i(program, location, v0, v1, v2);
-        }
-    }
-}
-
-void GL_APIENTRY
-ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
+void GL_APIENTRY ProgramUniform1iv(GLuint program,
+                                   GLint location,
+                                   GLsizei count,
+                                   const GLint *value)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d, "
-        "GLint v3 = %d)",
-        program, location, v0, v1, v2, v3);
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
+        "0x%0.8p)",
+        program, location, count, value);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform4i>(program, location, v0, v1, v2, v3);
+        context->gatherParams<EntryPoint::ProgramUniform1iv>(program, location, count, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform4i(context, program, location, v0, v1, v2, v3))
+            ValidateProgramUniform1iv(context, program, location, count, value))
         {
-            context->programUniform4i(program, location, v0, v1, v2, v3);
+            context->programUniform1iv(program, location, count, value);
         }
     }
 }
@@ -473,77 +635,25 @@ void GL_APIENTRY ProgramUniform1ui(GLuint program, GLint location, GLuint v0)
     }
 }
 
-void GL_APIENTRY ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
-    EVENT("(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u)", program,
-          location, v0, v1);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::ProgramUniform2ui>(program, location, v0, v1);
-
-        if (context->skipValidation() ||
-            ValidateProgramUniform2ui(context, program, location, v0, v1))
-        {
-            context->programUniform2ui(program, location, v0, v1);
-        }
-    }
-}
-
-void GL_APIENTRY ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    EVENT(
-        "(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = "
-        "%u)",
-        program, location, v0, v1, v2);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::ProgramUniform3ui>(program, location, v0, v1, v2);
-
-        if (context->skipValidation() ||
-            ValidateProgramUniform3ui(context, program, location, v0, v1, v2))
-        {
-            context->programUniform3ui(program, location, v0, v1, v2);
-        }
-    }
-}
-
-void GL_APIENTRY
-ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
+void GL_APIENTRY ProgramUniform1uiv(GLuint program,
+                                    GLint location,
+                                    GLsizei count,
+                                    const GLuint *value)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = "
-        "%u, GLuint v3 = %u)",
-        program, location, v0, v1, v2, v3);
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
+        "0x%0.8p)",
+        program, location, count, value);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform4ui>(program, location, v0, v1, v2, v3);
+        context->gatherParams<EntryPoint::ProgramUniform1uiv>(program, location, count, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform4ui(context, program, location, v0, v1, v2, v3))
-        {
-            context->programUniform4ui(program, location, v0, v1, v2, v3);
-        }
-    }
-}
-
-void GL_APIENTRY ProgramUniform1f(GLuint program, GLint location, GLfloat v0)
-{
-    EVENT("(GLuint program = %u, GLint location = %d, GLfloat v0 = %f)", program, location, v0);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::ProgramUniform1f>(program, location, v0);
-
-        if (context->skipValidation() || ValidateProgramUniform1f(context, program, location, v0))
+            ValidateProgramUniform1uiv(context, program, location, count, value))
         {
-            context->programUniform1f(program, location, v0);
+            context->programUniform1uiv(program, location, count, value);
         }
     }
 }
@@ -566,49 +676,48 @@ void GL_APIENTRY ProgramUniform2f(GLuint program, GLint location, GLfloat v0, GL
     }
 }
 
-void GL_APIENTRY
-ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
+void GL_APIENTRY ProgramUniform2fv(GLuint program,
+                                   GLint location,
+                                   GLsizei count,
+                                   const GLfloat *value)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = "
-        "%f)",
-        program, location, v0, v1, v2);
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
+        "0x%0.8p)",
+        program, location, count, value);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform3f>(program, location, v0, v1, v2);
+        context->gatherParams<EntryPoint::ProgramUniform2fv>(program, location, count, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform3f(context, program, location, v0, v1, v2))
+            ValidateProgramUniform2fv(context, program, location, count, value))
         {
-            context->programUniform3f(program, location, v0, v1, v2);
+            context->programUniform2fv(program, location, count, value);
         }
     }
 }
 
-void GL_APIENTRY
-ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
+void GL_APIENTRY ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 {
-    EVENT(
-        "(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = "
-        "%f, GLfloat v3 = %f)",
-        program, location, v0, v1, v2, v3);
+    EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d)", program,
+          location, v0, v1);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform4f>(program, location, v0, v1, v2, v3);
+        context->gatherParams<EntryPoint::ProgramUniform2i>(program, location, v0, v1);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform4f(context, program, location, v0, v1, v2, v3))
+            ValidateProgramUniform2i(context, program, location, v0, v1))
         {
-            context->programUniform4f(program, location, v0, v1, v2, v3);
+            context->programUniform2i(program, location, v0, v1);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniform1iv(GLuint program,
+void GL_APIENTRY ProgramUniform2iv(GLuint program,
                                    GLint location,
                                    GLsizei count,
                                    const GLint *value)
@@ -621,155 +730,163 @@ void GL_APIENTRY ProgramUniform1iv(GLuint program,
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform1iv>(program, location, count, value);
+        context->gatherParams<EntryPoint::ProgramUniform2iv>(program, location, count, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform1iv(context, program, location, count, value))
+            ValidateProgramUniform2iv(context, program, location, count, value))
         {
-            context->programUniform1iv(program, location, count, value);
+            context->programUniform2iv(program, location, count, value);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniform2iv(GLuint program,
-                                   GLint location,
-                                   GLsizei count,
-                                   const GLint *value)
+void GL_APIENTRY ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
+{
+    EVENT("(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u)", program,
+          location, v0, v1);
+
+    Context *context = GetValidGlobalContext();
+    if (context)
+    {
+        context->gatherParams<EntryPoint::ProgramUniform2ui>(program, location, v0, v1);
+
+        if (context->skipValidation() ||
+            ValidateProgramUniform2ui(context, program, location, v0, v1))
+        {
+            context->programUniform2ui(program, location, v0, v1);
+        }
+    }
+}
+
+void GL_APIENTRY ProgramUniform2uiv(GLuint program,
+                                    GLint location,
+                                    GLsizei count,
+                                    const GLuint *value)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
         "0x%0.8p)",
         program, location, count, value);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform2iv>(program, location, count, value);
+        context->gatherParams<EntryPoint::ProgramUniform2uiv>(program, location, count, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform2iv(context, program, location, count, value))
+            ValidateProgramUniform2uiv(context, program, location, count, value))
         {
-            context->programUniform2iv(program, location, count, value);
+            context->programUniform2uiv(program, location, count, value);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniform3iv(GLuint program,
-                                   GLint location,
-                                   GLsizei count,
-                                   const GLint *value)
+void GL_APIENTRY
+ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
-        "0x%0.8p)",
-        program, location, count, value);
+        "(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = "
+        "%f)",
+        program, location, v0, v1, v2);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform3iv>(program, location, count, value);
+        context->gatherParams<EntryPoint::ProgramUniform3f>(program, location, v0, v1, v2);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform3iv(context, program, location, count, value))
+            ValidateProgramUniform3f(context, program, location, v0, v1, v2))
         {
-            context->programUniform3iv(program, location, count, value);
+            context->programUniform3f(program, location, v0, v1, v2);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniform4iv(GLuint program,
+void GL_APIENTRY ProgramUniform3fv(GLuint program,
                                    GLint location,
                                    GLsizei count,
-                                   const GLint *value)
+                                   const GLfloat *value)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
         "0x%0.8p)",
         program, location, count, value);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform4iv>(program, location, count, value);
+        context->gatherParams<EntryPoint::ProgramUniform3fv>(program, location, count, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform4iv(context, program, location, count, value))
+            ValidateProgramUniform3fv(context, program, location, count, value))
         {
-            context->programUniform4iv(program, location, count, value);
+            context->programUniform3fv(program, location, count, value);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniform1uiv(GLuint program,
-                                    GLint location,
-                                    GLsizei count,
-                                    const GLuint *value)
+void GL_APIENTRY ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
 {
-    EVENT(
-        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
-        "0x%0.8p)",
-        program, location, count, value);
+    EVENT("(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d)",
+          program, location, v0, v1, v2);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform1uiv>(program, location, count, value);
+        context->gatherParams<EntryPoint::ProgramUniform3i>(program, location, v0, v1, v2);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform1uiv(context, program, location, count, value))
+            ValidateProgramUniform3i(context, program, location, v0, v1, v2))
         {
-            context->programUniform1uiv(program, location, count, value);
+            context->programUniform3i(program, location, v0, v1, v2);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniform2uiv(GLuint program,
-                                    GLint location,
-                                    GLsizei count,
-                                    const GLuint *value)
+void GL_APIENTRY ProgramUniform3iv(GLuint program,
+                                   GLint location,
+                                   GLsizei count,
+                                   const GLint *value)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
         "0x%0.8p)",
         program, location, count, value);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform2uiv>(program, location, count, value);
+        context->gatherParams<EntryPoint::ProgramUniform3iv>(program, location, count, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform2uiv(context, program, location, count, value))
+            ValidateProgramUniform3iv(context, program, location, count, value))
         {
-            context->programUniform2uiv(program, location, count, value);
+            context->programUniform3iv(program, location, count, value);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniform3uiv(GLuint program,
-                                    GLint location,
-                                    GLsizei count,
-                                    const GLuint *value)
+void GL_APIENTRY ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
-        "0x%0.8p)",
-        program, location, count, value);
+        "(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = "
+        "%u)",
+        program, location, v0, v1, v2);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform3uiv>(program, location, count, value);
+        context->gatherParams<EntryPoint::ProgramUniform3ui>(program, location, v0, v1, v2);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform3uiv(context, program, location, count, value))
+            ValidateProgramUniform3ui(context, program, location, v0, v1, v2))
         {
-            context->programUniform3uiv(program, location, count, value);
+            context->programUniform3ui(program, location, v0, v1, v2);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniform4uiv(GLuint program,
+void GL_APIENTRY ProgramUniform3uiv(GLuint program,
                                     GLint location,
                                     GLsizei count,
                                     const GLuint *value)
@@ -782,40 +899,38 @@ void GL_APIENTRY ProgramUniform4uiv(GLuint program,
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform4uiv>(program, location, count, value);
+        context->gatherParams<EntryPoint::ProgramUniform3uiv>(program, location, count, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform4uiv(context, program, location, count, value))
+            ValidateProgramUniform3uiv(context, program, location, count, value))
         {
-            context->programUniform4uiv(program, location, count, value);
+            context->programUniform3uiv(program, location, count, value);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniform1fv(GLuint program,
-                                   GLint location,
-                                   GLsizei count,
-                                   const GLfloat *value)
+void GL_APIENTRY
+ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
-        "0x%0.8p)",
-        program, location, count, value);
+        "(GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f, GLfloat v2 = "
+        "%f, GLfloat v3 = %f)",
+        program, location, v0, v1, v2, v3);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform1fv>(program, location, count, value);
+        context->gatherParams<EntryPoint::ProgramUniform4f>(program, location, v0, v1, v2, v3);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform1fv(context, program, location, count, value))
+            ValidateProgramUniform4f(context, program, location, v0, v1, v2, v3))
         {
-            context->programUniform1fv(program, location, count, value);
+            context->programUniform4f(program, location, v0, v1, v2, v3);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniform2fv(GLuint program,
+void GL_APIENTRY ProgramUniform4fv(GLuint program,
                                    GLint location,
                                    GLsizei count,
                                    const GLfloat *value)
@@ -828,113 +943,105 @@ void GL_APIENTRY ProgramUniform2fv(GLuint program,
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform2fv>(program, location, count, value);
+        context->gatherParams<EntryPoint::ProgramUniform4fv>(program, location, count, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform2fv(context, program, location, count, value))
+            ValidateProgramUniform4fv(context, program, location, count, value))
         {
-            context->programUniform2fv(program, location, count, value);
+            context->programUniform4fv(program, location, count, value);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniform3fv(GLuint program,
-                                   GLint location,
-                                   GLsizei count,
-                                   const GLfloat *value)
+void GL_APIENTRY
+ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
-        "0x%0.8p)",
-        program, location, count, value);
+        "(GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, GLint v2 = %d, "
+        "GLint v3 = %d)",
+        program, location, v0, v1, v2, v3);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform3fv>(program, location, count, value);
+        context->gatherParams<EntryPoint::ProgramUniform4i>(program, location, v0, v1, v2, v3);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform3fv(context, program, location, count, value))
+            ValidateProgramUniform4i(context, program, location, v0, v1, v2, v3))
         {
-            context->programUniform3fv(program, location, count, value);
+            context->programUniform4i(program, location, v0, v1, v2, v3);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniform4fv(GLuint program,
+void GL_APIENTRY ProgramUniform4iv(GLuint program,
                                    GLint location,
                                    GLsizei count,
-                                   const GLfloat *value)
+                                   const GLint *value)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLfloat *value = "
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint *value = "
         "0x%0.8p)",
         program, location, count, value);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniform4fv>(program, location, count, value);
+        context->gatherParams<EntryPoint::ProgramUniform4iv>(program, location, count, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniform4fv(context, program, location, count, value))
+            ValidateProgramUniform4iv(context, program, location, count, value))
         {
-            context->programUniform4fv(program, location, count, value);
+            context->programUniform4iv(program, location, count, value);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniformMatrix2fv(GLuint program,
-                                         GLint location,
-                                         GLsizei count,
-                                         GLboolean transpose,
-                                         const GLfloat *value)
+void GL_APIENTRY
+ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
-        "const GLfloat *value = 0x%0.8p)",
-        program, location, count, transpose, value);
+        "(GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, GLuint v2 = "
+        "%u, GLuint v3 = %u)",
+        program, location, v0, v1, v2, v3);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniformMatrix2fv>(program, location, count,
-                                                                   transpose, value);
+        context->gatherParams<EntryPoint::ProgramUniform4ui>(program, location, v0, v1, v2, v3);
 
         if (context->skipValidation() ||
-            ValidateProgramUniformMatrix2fv(context, program, location, count, transpose, value))
+            ValidateProgramUniform4ui(context, program, location, v0, v1, v2, v3))
         {
-            context->programUniformMatrix2fv(program, location, count, transpose, value);
+            context->programUniform4ui(program, location, v0, v1, v2, v3);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniformMatrix3fv(GLuint program,
-                                         GLint location,
-                                         GLsizei count,
-                                         GLboolean transpose,
-                                         const GLfloat *value)
+void GL_APIENTRY ProgramUniform4uiv(GLuint program,
+                                    GLint location,
+                                    GLsizei count,
+                                    const GLuint *value)
 {
     EVENT(
-        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
-        "const GLfloat *value = 0x%0.8p)",
-        program, location, count, transpose, value);
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLuint *value = "
+        "0x%0.8p)",
+        program, location, count, value);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniformMatrix3fv>(program, location, count,
-                                                                   transpose, value);
+        context->gatherParams<EntryPoint::ProgramUniform4uiv>(program, location, count, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniformMatrix3fv(context, program, location, count, transpose, value))
+            ValidateProgramUniform4uiv(context, program, location, count, value))
         {
-            context->programUniformMatrix3fv(program, location, count, transpose, value);
+            context->programUniform4uiv(program, location, count, value);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniformMatrix4fv(GLuint program,
+void GL_APIENTRY ProgramUniformMatrix2fv(GLuint program,
                                          GLint location,
                                          GLsizei count,
                                          GLboolean transpose,
@@ -948,13 +1055,13 @@ void GL_APIENTRY ProgramUniformMatrix4fv(GLuint program,
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniformMatrix4fv>(program, location, count,
+        context->gatherParams<EntryPoint::ProgramUniformMatrix2fv>(program, location, count,
                                                                    transpose, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniformMatrix4fv(context, program, location, count, transpose, value))
+            ValidateProgramUniformMatrix2fv(context, program, location, count, transpose, value))
         {
-            context->programUniformMatrix4fv(program, location, count, transpose, value);
+            context->programUniformMatrix2fv(program, location, count, transpose, value);
         }
     }
 }
@@ -984,7 +1091,7 @@ void GL_APIENTRY ProgramUniformMatrix2x3fv(GLuint program,
     }
 }
 
-void GL_APIENTRY ProgramUniformMatrix3x2fv(GLuint program,
+void GL_APIENTRY ProgramUniformMatrix2x4fv(GLuint program,
                                            GLint location,
                                            GLsizei count,
                                            GLboolean transpose,
@@ -998,22 +1105,22 @@ void GL_APIENTRY ProgramUniformMatrix3x2fv(GLuint program,
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniformMatrix3x2fv>(program, location, count,
+        context->gatherParams<EntryPoint::ProgramUniformMatrix2x4fv>(program, location, count,
                                                                      transpose, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniformMatrix3x2fv(context, program, location, count, transpose, value))
+            ValidateProgramUniformMatrix2x4fv(context, program, location, count, transpose, value))
         {
-            context->programUniformMatrix3x2fv(program, location, count, transpose, value);
+            context->programUniformMatrix2x4fv(program, location, count, transpose, value);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniformMatrix2x4fv(GLuint program,
-                                           GLint location,
-                                           GLsizei count,
-                                           GLboolean transpose,
-                                           const GLfloat *value)
+void GL_APIENTRY ProgramUniformMatrix3fv(GLuint program,
+                                         GLint location,
+                                         GLsizei count,
+                                         GLboolean transpose,
+                                         const GLfloat *value)
 {
     EVENT(
         "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
@@ -1023,18 +1130,18 @@ void GL_APIENTRY ProgramUniformMatrix2x4fv(GLuint program,
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniformMatrix2x4fv>(program, location, count,
-                                                                     transpose, value);
+        context->gatherParams<EntryPoint::ProgramUniformMatrix3fv>(program, location, count,
+                                                                   transpose, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniformMatrix2x4fv(context, program, location, count, transpose, value))
+            ValidateProgramUniformMatrix3fv(context, program, location, count, transpose, value))
         {
-            context->programUniformMatrix2x4fv(program, location, count, transpose, value);
+            context->programUniformMatrix3fv(program, location, count, transpose, value);
         }
     }
 }
 
-void GL_APIENTRY ProgramUniformMatrix4x2fv(GLuint program,
+void GL_APIENTRY ProgramUniformMatrix3x2fv(GLuint program,
                                            GLint location,
                                            GLsizei count,
                                            GLboolean transpose,
@@ -1048,13 +1155,13 @@ void GL_APIENTRY ProgramUniformMatrix4x2fv(GLuint program,
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniformMatrix4x2fv>(program, location, count,
+        context->gatherParams<EntryPoint::ProgramUniformMatrix3x2fv>(program, location, count,
                                                                      transpose, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniformMatrix4x2fv(context, program, location, count, transpose, value))
+            ValidateProgramUniformMatrix3x2fv(context, program, location, count, transpose, value))
         {
-            context->programUniformMatrix4x2fv(program, location, count, transpose, value);
+            context->programUniformMatrix3x2fv(program, location, count, transpose, value);
         }
     }
 }
@@ -1084,11 +1191,11 @@ void GL_APIENTRY ProgramUniformMatrix3x4fv(GLuint program,
     }
 }
 
-void GL_APIENTRY ProgramUniformMatrix4x3fv(GLuint program,
-                                           GLint location,
-                                           GLsizei count,
-                                           GLboolean transpose,
-                                           const GLfloat *value)
+void GL_APIENTRY ProgramUniformMatrix4fv(GLuint program,
+                                         GLint location,
+                                         GLsizei count,
+                                         GLboolean transpose,
+                                         const GLfloat *value)
 {
     EVENT(
         "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
@@ -1098,129 +1205,79 @@ void GL_APIENTRY ProgramUniformMatrix4x3fv(GLuint program,
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::ProgramUniformMatrix4x3fv>(program, location, count,
-                                                                     transpose, value);
+        context->gatherParams<EntryPoint::ProgramUniformMatrix4fv>(program, location, count,
+                                                                   transpose, value);
 
         if (context->skipValidation() ||
-            ValidateProgramUniformMatrix4x3fv(context, program, location, count, transpose, value))
-        {
-            context->programUniformMatrix4x3fv(program, location, count, transpose, value);
-        }
-    }
-}
-
-void GL_APIENTRY ValidateProgramPipeline(GLuint pipeline)
-{
-    EVENT("(GLuint pipeline = %u)", pipeline);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::ValidateProgramPipeline>(pipeline);
-
-        if (context->skipValidation() || ValidateValidateProgramPipeline(context, pipeline))
+            ValidateProgramUniformMatrix4fv(context, program, location, count, transpose, value))
         {
-            context->validateProgramPipeline(pipeline);
+            context->programUniformMatrix4fv(program, location, count, transpose, value);
         }
     }
 }
 
-void GL_APIENTRY GetProgramPipelineInfoLog(GLuint pipeline,
-                                           GLsizei bufSize,
-                                           GLsizei *length,
-                                           GLchar *infoLog)
+void GL_APIENTRY ProgramUniformMatrix4x2fv(GLuint program,
+                                           GLint location,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value)
 {
     EVENT(
-        "(GLuint pipeline = %u, GLsizei bufSize = %d, GLsizei *length = 0x%0.8p, GLchar *infoLog = "
-        "0x%0.8p)",
-        pipeline, bufSize, length, infoLog);
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%0.8p)",
+        program, location, count, transpose, value);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::GetProgramPipelineInfoLog>(pipeline, bufSize, length,
-                                                                     infoLog);
+        context->gatherParams<EntryPoint::ProgramUniformMatrix4x2fv>(program, location, count,
+                                                                     transpose, value);
 
         if (context->skipValidation() ||
-            ValidateGetProgramPipelineInfoLog(context, pipeline, bufSize, length, infoLog))
+            ValidateProgramUniformMatrix4x2fv(context, program, location, count, transpose, value))
         {
-            context->getProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+            context->programUniformMatrix4x2fv(program, location, count, transpose, value);
         }
     }
 }
 
-void GL_APIENTRY BindImageTexture(GLuint unit,
-                                  GLuint texture,
-                                  GLint level,
-                                  GLboolean layered,
-                                  GLint layer,
-                                  GLenum access,
-                                  GLenum format)
+void GL_APIENTRY ProgramUniformMatrix4x3fv(GLuint program,
+                                           GLint location,
+                                           GLsizei count,
+                                           GLboolean transpose,
+                                           const GLfloat *value)
 {
     EVENT(
-        "(GLuint unit = %u, GLuint texture = %u, GLint level = %d, GLboolean layered = %u, GLint "
-        "layer = %d, GLenum access = 0x%X, GLenum format = 0x%X)",
-        unit, texture, level, layered, layer, access, format);
+        "(GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean transpose = %u, "
+        "const GLfloat *value = 0x%0.8p)",
+        program, location, count, transpose, value);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::BindImageTexture>(unit, texture, level, layered, layer,
-                                                            access, format);
+        context->gatherParams<EntryPoint::ProgramUniformMatrix4x3fv>(program, location, count,
+                                                                     transpose, value);
 
         if (context->skipValidation() ||
-            ValidateBindImageTexture(context, unit, texture, level, layered, layer, access, format))
-        {
-            context->bindImageTexture(unit, texture, level, layered, layer, access, format);
-        }
-    }
-}
-
-void GL_APIENTRY GetBooleani_v(GLenum target, GLuint index, GLboolean *data)
-{
-    EVENT("(GLenum target = 0x%X, GLuint index = %u, GLboolean *data = 0x%0.8p)", target, index,
-          data);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::GetBooleani_v>(target, index, data);
-
-        if (context->skipValidation() || ValidateGetBooleani_v(context, target, index, data))
-        {
-            context->getBooleani_v(target, index, data);
-        }
-    }
-}
-
-void GL_APIENTRY MemoryBarrier(GLbitfield barriers)
-{
-    EVENT("(GLbitfield barriers = 0x%X)", barriers);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::MemoryBarrier>(barriers);
-
-        if (context->skipValidation() || ValidateMemoryBarrier(context, barriers))
+            ValidateProgramUniformMatrix4x3fv(context, program, location, count, transpose, value))
         {
-            context->memoryBarrier(barriers);
+            context->programUniformMatrix4x3fv(program, location, count, transpose, value);
         }
     }
 }
 
-void GL_APIENTRY MemoryBarrierByRegion(GLbitfield barriers)
+void GL_APIENTRY SampleMaski(GLuint maskNumber, GLbitfield mask)
 {
-    EVENT("(GLbitfield barriers = 0x%X)", barriers);
+    EVENT("(GLuint maskNumber = %u, GLbitfield mask = 0x%X)", maskNumber, mask);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::MemoryBarrierByRegion>(barriers);
+        context->gatherParams<EntryPoint::SampleMaski>(maskNumber, mask);
 
-        if (context->skipValidation() || ValidateMemoryBarrierByRegion(context, barriers))
+        if (context->skipValidation() || ValidateSampleMaski(context, maskNumber, mask))
         {
-            context->memoryBarrierByRegion(barriers);
+            context->sampleMaski(maskNumber, mask);
         }
     }
 }
@@ -1253,93 +1310,53 @@ void GL_APIENTRY TexStorage2DMultisample(GLenum target,
     }
 }
 
-void GL_APIENTRY GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
-{
-    EVENT("(GLenum pname = 0x%X, GLuint index = %u, GLfloat *val = 0x%0.8p)", pname, index, val);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::GetMultisamplefv>(pname, index, val);
-
-        if (context->skipValidation() || ValidateGetMultisamplefv(context, pname, index, val))
-        {
-            context->getMultisamplefv(pname, index, val);
-        }
-    }
-}
-
-void GL_APIENTRY SampleMaski(GLuint maskNumber, GLbitfield mask)
-{
-    EVENT("(GLuint maskNumber = %u, GLbitfield mask = 0x%X)", maskNumber, mask);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::SampleMaski>(maskNumber, mask);
-
-        if (context->skipValidation() || ValidateSampleMaski(context, maskNumber, mask))
-        {
-            context->sampleMaski(maskNumber, mask);
-        }
-    }
-}
-
-void GL_APIENTRY GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
+void GL_APIENTRY UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
 {
-    EVENT("(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLint *params = 0x%0.8p)",
-          target, level, pname, params);
+    EVENT("(GLuint pipeline = %u, GLbitfield stages = 0x%X, GLuint program = %u)", pipeline, stages,
+          program);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::GetTexLevelParameteriv>(target, level, pname, params);
+        context->gatherParams<EntryPoint::UseProgramStages>(pipeline, stages, program);
 
         if (context->skipValidation() ||
-            ValidateGetTexLevelParameteriv(context, target, level, pname, params))
+            ValidateUseProgramStages(context, pipeline, stages, program))
         {
-            context->getTexLevelParameteriv(target, level, pname, params);
+            context->useProgramStages(pipeline, stages, program);
         }
     }
 }
 
-void GL_APIENTRY GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
+void GL_APIENTRY ValidateProgramPipeline(GLuint pipeline)
 {
-    EVENT(
-        "(GLenum target = 0x%X, GLint level = %d, GLenum pname = 0x%X, GLfloat *params = 0x%0.8p)",
-        target, level, pname, params);
+    EVENT("(GLuint pipeline = %u)", pipeline);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::GetTexLevelParameterfv>(target, level, pname, params);
+        context->gatherParams<EntryPoint::ValidateProgramPipeline>(pipeline);
 
-        if (context->skipValidation() ||
-            ValidateGetTexLevelParameterfv(context, target, level, pname, params))
+        if (context->skipValidation() || ValidateValidateProgramPipeline(context, pipeline))
         {
-            context->getTexLevelParameterfv(target, level, pname, params);
+            context->validateProgramPipeline(pipeline);
         }
     }
 }
 
-void GL_APIENTRY BindVertexBuffer(GLuint bindingindex,
-                                  GLuint buffer,
-                                  GLintptr offset,
-                                  GLsizei stride)
+void GL_APIENTRY VertexAttribBinding(GLuint attribindex, GLuint bindingindex)
 {
-    EVENT(
-        "(GLuint bindingindex = %u, GLuint buffer = %u, GLintptr offset = %d, GLsizei stride = %d)",
-        bindingindex, buffer, offset, stride);
+    EVENT("(GLuint attribindex = %u, GLuint bindingindex = %u)", attribindex, bindingindex);
 
     Context *context = GetValidGlobalContext();
     if (context)
     {
-        context->gatherParams<EntryPoint::BindVertexBuffer>(bindingindex, buffer, offset, stride);
+        context->gatherParams<EntryPoint::VertexAttribBinding>(attribindex, bindingindex);
 
         if (context->skipValidation() ||
-            ValidateBindVertexBuffer(context, bindingindex, buffer, offset, stride))
+            ValidateVertexAttribBinding(context, attribindex, bindingindex))
         {
-            context->bindVertexBuffer(bindingindex, buffer, offset, stride);
+            context->vertexAttribBinding(attribindex, bindingindex);
         }
     }
 }
@@ -1394,23 +1411,6 @@ void GL_APIENTRY VertexAttribIFormat(GLuint attribindex,
     }
 }
 
-void GL_APIENTRY VertexAttribBinding(GLuint attribindex, GLuint bindingindex)
-{
-    EVENT("(GLuint attribindex = %u, GLuint bindingindex = %u)", attribindex, bindingindex);
-
-    Context *context = GetValidGlobalContext();
-    if (context)
-    {
-        context->gatherParams<EntryPoint::VertexAttribBinding>(attribindex, bindingindex);
-
-        if (context->skipValidation() ||
-            ValidateVertexAttribBinding(context, attribindex, bindingindex))
-        {
-            context->vertexAttribBinding(attribindex, bindingindex);
-        }
-    }
-}
-
 void GL_APIENTRY VertexBindingDivisor(GLuint bindingindex, GLuint divisor)
 {
     EVENT("(GLuint bindingindex = %u, GLuint divisor = %u)", bindingindex, divisor);

src/libGLESv2/entry_points_gles_3_1_autogen.h

@@ -18,6 +18,23 @@
 
 namespace gl
 {
+ANGLE_EXPORT void GL_APIENTRY ActiveShaderProgram(GLuint pipeline, GLuint program);
+ANGLE_EXPORT void GL_APIENTRY BindImageTexture(GLuint unit,
+                                               GLuint texture,
+                                               GLint level,
+                                               GLboolean layered,
+                                               GLint layer,
+                                               GLenum access,
+                                               GLenum format);
+ANGLE_EXPORT void GL_APIENTRY BindProgramPipeline(GLuint pipeline);
+ANGLE_EXPORT void GL_APIENTRY BindVertexBuffer(GLuint bindingindex,
+                                               GLuint buffer,
+                                               GLintptr offset,
+                                               GLsizei stride);
+ANGLE_EXPORT GLuint GL_APIENTRY CreateShaderProgramv(GLenum type,
+                                                     GLsizei count,
+                                                     const GLchar *const *strings);
+ANGLE_EXPORT void GL_APIENTRY DeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
 ANGLE_EXPORT void GL_APIENTRY DispatchCompute(GLuint num_groups_x,
                                               GLuint num_groups_y,
                                               GLuint num_groups_z);
@@ -25,14 +42,25 @@ ANGLE_EXPORT void GL_APIENTRY DispatchComputeIndirect(GLintptr indirect);
 ANGLE_EXPORT void GL_APIENTRY DrawArraysIndirect(GLenum mode, const void *indirect);
 ANGLE_EXPORT void GL_APIENTRY DrawElementsIndirect(GLenum mode, GLenum type, const void *indirect);
 ANGLE_EXPORT void GL_APIENTRY FramebufferParameteri(GLenum target, GLenum pname, GLint param);
+ANGLE_EXPORT void GL_APIENTRY GenProgramPipelines(GLsizei n, GLuint *pipelines);
+ANGLE_EXPORT void GL_APIENTRY GetBooleani_v(GLenum target, GLuint index, GLboolean *data);
 ANGLE_EXPORT void GL_APIENTRY GetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
 ANGLE_EXPORT void GL_APIENTRY GetProgramInterfaceiv(GLuint program,
                                                     GLenum programInterface,
                                                     GLenum pname,
                                                     GLint *params);
+ANGLE_EXPORT void GL_APIENTRY GetProgramPipelineInfoLog(GLuint pipeline,
+                                                        GLsizei bufSize,
+                                                        GLsizei *length,
+                                                        GLchar *infoLog);
+ANGLE_EXPORT void GL_APIENTRY GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
 ANGLE_EXPORT GLuint GL_APIENTRY GetProgramResourceIndex(GLuint program,
                                                         GLenum programInterface,
                                                         const GLchar *name);
+ANGLE_EXPORT GLint GL_APIENTRY GetProgramResourceLocation(GLuint program,
+                                                          GLenum programInterface,
+                                                          const GLchar *name);
 ANGLE_EXPORT void GL_APIENTRY GetProgramResourceName(GLuint program,
                                                      GLenum programInterface,
                                                      GLuint index,
@@ -47,127 +75,125 @@ ANGLE_EXPORT void GL_APIENTRY GetProgramResourceiv(GLuint program,
                                                    GLsizei bufSize,
                                                    GLsizei *length,
                                                    GLint *params);
-ANGLE_EXPORT GLint GL_APIENTRY GetProgramResourceLocation(GLuint program,
-                                                          GLenum programInterface,
-                                                          const GLchar *name);
-ANGLE_EXPORT void GL_APIENTRY UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
-ANGLE_EXPORT void GL_APIENTRY ActiveShaderProgram(GLuint pipeline, GLuint program);
-ANGLE_EXPORT GLuint GL_APIENTRY CreateShaderProgramv(GLenum type,
-                                                     GLsizei count,
-                                                     const GLchar *const *strings);
-ANGLE_EXPORT void GL_APIENTRY BindProgramPipeline(GLuint pipeline);
-ANGLE_EXPORT void GL_APIENTRY DeleteProgramPipelines(GLsizei n, const GLuint *pipelines);
-ANGLE_EXPORT void GL_APIENTRY GenProgramPipelines(GLsizei n, GLuint *pipelines);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterfv(GLenum target,
+                                                     GLint level,
+                                                     GLenum pname,
+                                                     GLfloat *params);
+ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameteriv(GLenum target,
+                                                     GLint level,
+                                                     GLenum pname,
+                                                     GLint *params);
 ANGLE_EXPORT GLboolean GL_APIENTRY IsProgramPipeline(GLuint pipeline);
-ANGLE_EXPORT void GL_APIENTRY GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params);
+ANGLE_EXPORT void GL_APIENTRY MemoryBarrier(GLbitfield barriers);
+ANGLE_EXPORT void GL_APIENTRY MemoryBarrierByRegion(GLbitfield barriers);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1f(GLuint program, GLint location, GLfloat v0);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1fv(GLuint program,
+                                                GLint location,
+                                                GLsizei count,
+                                                const GLfloat *value);
 ANGLE_EXPORT void GL_APIENTRY ProgramUniform1i(GLuint program, GLint location, GLint v0);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
-ANGLE_EXPORT void GL_APIENTRY
-ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-ANGLE_EXPORT void GL_APIENTRY
-ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform1ui(GLuint program, GLint location, GLuint v0);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform2ui(GLuint program,
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1iv(GLuint program,
                                                 GLint location,
-                                                GLuint v0,
-                                                GLuint v1);
-ANGLE_EXPORT void GL_APIENTRY
-ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-ANGLE_EXPORT void GL_APIENTRY
-ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform1f(GLuint program, GLint location, GLfloat v0);
+                                                GLsizei count,
+                                                const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1ui(GLuint program, GLint location, GLuint v0);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform1uiv(GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLuint *value);
 ANGLE_EXPORT void GL_APIENTRY ProgramUniform2f(GLuint program,
                                                GLint location,
                                                GLfloat v0,
                                                GLfloat v1);
-ANGLE_EXPORT void GL_APIENTRY
-ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-ANGLE_EXPORT void GL_APIENTRY
-ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform1iv(GLuint program,
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2fv(GLuint program,
                                                 GLint location,
                                                 GLsizei count,
-                                                const GLint *value);
+                                                const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1);
 ANGLE_EXPORT void GL_APIENTRY ProgramUniform2iv(GLuint program,
                                                 GLint location,
                                                 GLsizei count,
                                                 const GLint *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform3iv(GLuint program,
-                                                GLint location,
-                                                GLsizei count,
-                                                const GLint *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform4iv(GLuint program,
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform2ui(GLuint program,
                                                 GLint location,
-                                                GLsizei count,
-                                                const GLint *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform1uiv(GLuint program,
-                                                 GLint location,
-                                                 GLsizei count,
-                                                 const GLuint *value);
+                                                GLuint v0,
+                                                GLuint v1);
 ANGLE_EXPORT void GL_APIENTRY ProgramUniform2uiv(GLuint program,
                                                  GLint location,
                                                  GLsizei count,
                                                  const GLuint *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform3uiv(GLuint program,
-                                                 GLint location,
-                                                 GLsizei count,
-                                                 const GLuint *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform4uiv(GLuint program,
-                                                 GLint location,
-                                                 GLsizei count,
-                                                 const GLuint *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform1fv(GLuint program,
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform3fv(GLuint program,
                                                 GLint location,
                                                 GLsizei count,
                                                 const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform2fv(GLuint program,
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform3iv(GLuint program,
                                                 GLint location,
                                                 GLsizei count,
-                                                const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform3fv(GLuint program,
+                                                const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform3uiv(GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLuint *value);
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform4fv(GLuint program,
                                                 GLint location,
                                                 GLsizei count,
                                                 const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniform4fv(GLuint program,
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform4iv(GLuint program,
                                                 GLint location,
                                                 GLsizei count,
-                                                const GLfloat *value);
+                                                const GLint *value);
+ANGLE_EXPORT void GL_APIENTRY
+ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniform4uiv(GLuint program,
+                                                 GLint location,
+                                                 GLsizei count,
+                                                 const GLuint *value);
 ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix2fv(GLuint program,
                                                       GLint location,
                                                       GLsizei count,
                                                       GLboolean transpose,
                                                       const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix3fv(GLuint program,
-                                                      GLint location,
-                                                      GLsizei count,
-                                                      GLboolean transpose,
-                                                      const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix4fv(GLuint program,
-                                                      GLint location,
-                                                      GLsizei count,
-                                                      GLboolean transpose,
-                                                      const GLfloat *value);
 ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix2x3fv(GLuint program,
                                                         GLint location,
                                                         GLsizei count,
                                                         GLboolean transpose,
                                                         const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix3x2fv(GLuint program,
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix2x4fv(GLuint program,
                                                         GLint location,
                                                         GLsizei count,
                                                         GLboolean transpose,
                                                         const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix2x4fv(GLuint program,
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix3fv(GLuint program,
+                                                      GLint location,
+                                                      GLsizei count,
+                                                      GLboolean transpose,
+                                                      const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix3x2fv(GLuint program,
                                                         GLint location,
                                                         GLsizei count,
                                                         GLboolean transpose,
                                                         const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix4x2fv(GLuint program,
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix3x4fv(GLuint program,
                                                         GLint location,
                                                         GLsizei count,
                                                         GLboolean transpose,
                                                         const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix3x4fv(GLuint program,
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix4fv(GLuint program,
+                                                      GLint location,
+                                                      GLsizei count,
+                                                      GLboolean transpose,
+                                                      const GLfloat *value);
+ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix4x2fv(GLuint program,
                                                         GLint location,
                                                         GLsizei count,
                                                         GLboolean transpose,
@@ -177,41 +203,16 @@ ANGLE_EXPORT void GL_APIENTRY ProgramUniformMatrix4x3fv(GLuint program,
                                                         GLsizei count,
                                                         GLboolean transpose,
                                                         const GLfloat *value);
-ANGLE_EXPORT void GL_APIENTRY ValidateProgramPipeline(GLuint pipeline);
-ANGLE_EXPORT void GL_APIENTRY GetProgramPipelineInfoLog(GLuint pipeline,
-                                                        GLsizei bufSize,
-                                                        GLsizei *length,
-                                                        GLchar *infoLog);
-ANGLE_EXPORT void GL_APIENTRY BindImageTexture(GLuint unit,
-                                               GLuint texture,
-                                               GLint level,
-                                               GLboolean layered,
-                                               GLint layer,
-                                               GLenum access,
-                                               GLenum format);
-ANGLE_EXPORT void GL_APIENTRY GetBooleani_v(GLenum target, GLuint index, GLboolean *data);
-ANGLE_EXPORT void GL_APIENTRY MemoryBarrier(GLbitfield barriers);
-ANGLE_EXPORT void GL_APIENTRY MemoryBarrierByRegion(GLbitfield barriers);
+ANGLE_EXPORT void GL_APIENTRY SampleMaski(GLuint maskNumber, GLbitfield mask);
 ANGLE_EXPORT void GL_APIENTRY TexStorage2DMultisample(GLenum target,
                                                       GLsizei samples,
                                                       GLenum internalformat,
                                                       GLsizei width,
                                                       GLsizei height,
                                                       GLboolean fixedsamplelocations);
-ANGLE_EXPORT void GL_APIENTRY GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val);
-ANGLE_EXPORT void GL_APIENTRY SampleMaski(GLuint maskNumber, GLbitfield mask);
-ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameteriv(GLenum target,
-                                                     GLint level,
-                                                     GLenum pname,
-                                                     GLint *params);
-ANGLE_EXPORT void GL_APIENTRY GetTexLevelParameterfv(GLenum target,
-                                                     GLint level,
-                                                     GLenum pname,
-                                                     GLfloat *params);
-ANGLE_EXPORT void GL_APIENTRY BindVertexBuffer(GLuint bindingindex,
-                                               GLuint buffer,
-                                               GLintptr offset,
-                                               GLsizei stride);
+ANGLE_EXPORT void GL_APIENTRY UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program);
+ANGLE_EXPORT void GL_APIENTRY ValidateProgramPipeline(GLuint pipeline);
+ANGLE_EXPORT void GL_APIENTRY VertexAttribBinding(GLuint attribindex, GLuint bindingindex);
 ANGLE_EXPORT void GL_APIENTRY VertexAttribFormat(GLuint attribindex,
                                                  GLint size,
                                                  GLenum type,
@@ -221,7 +222,6 @@ ANGLE_EXPORT void GL_APIENTRY VertexAttribIFormat(GLuint attribindex,
                                                   GLint size,
                                                   GLenum type,
                                                   GLuint relativeoffset);
-ANGLE_EXPORT void GL_APIENTRY VertexAttribBinding(GLuint attribindex, GLuint bindingindex);
 ANGLE_EXPORT void GL_APIENTRY VertexBindingDivisor(GLuint bindingindex, GLuint divisor);
 }  // namespace gl