kc3-lang/angle/src/libGLESv2/entry_points_gl_3_autogen.cpp

• Show log

  Commit

• Hash : d919870f
  Author :
  Date : 2023-09-14T16:00:07
  

  Vulkan: Do host image copy without holding the share group lock
  
  When an application uploads texture data such as with `glTexSubImage2D`,
  the share group lock is being hold while the data is being copied.
  Without VK_EXT_host_image_copy, this is a copy to a staging buffer,
  which may itself be expensive.  With VK_EXT_host_image_copy, the cost of
  the copy is higher and so the lock would be held for a longer duration.
  
  This is particularly harmful to applications that spawn a separate
  thread for texture uploads (as the main thread is unable to make GL
  calls).  This change moves the actual copy call to the tail of the call
  after the share group lock has been released.  As a result:
  
  - The upload thread may be a bit slower, but
  - The copy does not interfere with the main thread, and
  - The copy does not interfere with the GPU's rendering work.
  
  As a result, games that load content seamlessly during gameplay should
  experience less stutter during texture uploads.
  
  Bug: angleproject:8341
  Change-Id: I818c4389d4bf828847578da89414623e4b5e844e
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4864290
  Reviewed-by: Charlie Lao <cclao@google.com>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libGLESv2/entry_points_gl_3_autogen.cpp

• // GENERATED FILE - DO NOT EDIT.
  // Generated by generate_entry_points.py using data from gl.xml.
  //
  // Copyright 2020 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // entry_points_gl_3_autogen.cpp:
  //   Defines the Desktop GL 3.x entry points.
  
  #include "libGLESv2/entry_points_gl_3_autogen.h"
  
  #include "common/gl_enum_utils.h"
  #include "libANGLE/Context.h"
  #include "libANGLE/Context.inl.h"
  #include "libANGLE/capture/capture_gl_3_autogen.h"
  #include "libANGLE/context_private_call_gl_autogen.h"
  #include "libANGLE/context_private_call_gles_autogen.h"
  #include "libANGLE/entry_points_utils.h"
  #include "libANGLE/validationEGL.h"
  #include "libANGLE/validationES.h"
  #include "libANGLE/validationES1.h"
  #include "libANGLE/validationES2.h"
  #include "libANGLE/validationES3.h"
  #include "libANGLE/validationES31.h"
  #include "libANGLE/validationES32.h"
  #include "libANGLE/validationESEXT.h"
  #include "libANGLE/validationGL3_autogen.h"
  #include "libGLESv2/global_state.h"
  
  using namespace gl;
  
  extern "C" {
  
  // GL 3.0
  void GL_APIENTRY GL_BeginConditionalRender(GLuint id, GLenum mode)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLBeginConditionalRender, "context = %d, id = %u, mode = %s", CID(context), id,
            GLenumToString(BigGLEnum::ConditionalRenderMode, mode));
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLBeginConditionalRender) &&
                ValidateBeginConditionalRender(context, angle::EntryPoint::GLBeginConditionalRender,
                                               id, mode)));
          if (isCallValid)
          {
              context->beginConditionalRender(id, mode);
          }
          ANGLE_CAPTURE_GL(BeginConditionalRender, isCallValid, context, id, mode);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_BindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLBindFragDataLocation,
            "context = %d, program = %u, color = %u, name = 0x%016" PRIxPTR "", CID(context), program,
            color, (uintptr_t)name);
  
      if (context)
      {
          ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLBindFragDataLocation) &&
                ValidateBindFragDataLocation(context, angle::EntryPoint::GLBindFragDataLocation,
                                             programPacked, color, name)));
          if (isCallValid)
          {
              context->bindFragDataLocation(programPacked, color, name);
          }
          ANGLE_CAPTURE_GL(BindFragDataLocation, isCallValid, context, programPacked, color, name);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_ClampColor(GLenum target, GLenum clamp)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLClampColor, "context = %d, target = %s, clamp = %s", CID(context),
            GLenumToString(BigGLEnum::AllEnums, target), GLenumToString(BigGLEnum::AllEnums, clamp));
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLClampColor) &&
                ValidateClampColor(context, angle::EntryPoint::GLClampColor, target, clamp)));
          if (isCallValid)
          {
              context->clampColor(target, clamp);
          }
          ANGLE_CAPTURE_GL(ClampColor, isCallValid, context, target, clamp);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_EndConditionalRender()
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLEndConditionalRender, "context = %d", CID(context));
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLEndConditionalRender) &&
                ValidateEndConditionalRender(context, angle::EntryPoint::GLEndConditionalRender)));
          if (isCallValid)
          {
              context->endConditionalRender();
          }
          ANGLE_CAPTURE_GL(EndConditionalRender, isCallValid, context);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_FramebufferTexture1D(GLenum target,
                                           GLenum attachment,
                                           GLenum textarget,
                                           GLuint texture,
                                           GLint level)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLFramebufferTexture1D,
            "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d",
            CID(context), GLenumToString(BigGLEnum::FramebufferTarget, target),
            GLenumToString(BigGLEnum::FramebufferAttachment, attachment),
            GLenumToString(BigGLEnum::TextureTarget, textarget), texture, level);
  
      if (context)
      {
          TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
          TextureID texturePacked       = PackParam<TextureID>(texture);
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLFramebufferTexture1D) &&
                ValidateFramebufferTexture1D(context, angle::EntryPoint::GLFramebufferTexture1D,
                                             target, attachment, textargetPacked, texturePacked,
                                             level)));
          if (isCallValid)
          {
              context->framebufferTexture1D(target, attachment, textargetPacked, texturePacked,
                                            level);
          }
          ANGLE_CAPTURE_GL(FramebufferTexture1D, isCallValid, context, target, attachment,
                           textargetPacked, texturePacked, level);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_FramebufferTexture3D(GLenum target,
                                           GLenum attachment,
                                           GLenum textarget,
                                           GLuint texture,
                                           GLint level,
                                           GLint zoffset)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLFramebufferTexture3D,
            "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, "
            "zoffset = %d",
            CID(context), GLenumToString(BigGLEnum::FramebufferTarget, target),
            GLenumToString(BigGLEnum::FramebufferAttachment, attachment),
            GLenumToString(BigGLEnum::TextureTarget, textarget), texture, level, zoffset);
  
      if (context)
      {
          TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
          TextureID texturePacked       = PackParam<TextureID>(texture);
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLFramebufferTexture3D) &&
                ValidateFramebufferTexture3D(context, angle::EntryPoint::GLFramebufferTexture3D,
                                             target, attachment, textargetPacked, texturePacked,
                                             level, zoffset)));
          if (isCallValid)
          {
              context->framebufferTexture3D(target, attachment, textargetPacked, texturePacked, level,
                                            zoffset);
          }
          ANGLE_CAPTURE_GL(FramebufferTexture3D, isCallValid, context, target, attachment,
                           textargetPacked, texturePacked, level, zoffset);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI1i(GLuint index, GLint x)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI1i, "context = %d, index = %u, x = %d", CID(context), index, x);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI1i(context->getPrivateState(),
                                       context->getMutableErrorSetForValidation(),
                                       angle::EntryPoint::GLVertexAttribI1i, index, x));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI1i(context->getMutablePrivateState(),
                                            context->getMutablePrivateStateCache(), index, x);
          }
          ANGLE_CAPTURE_GL(VertexAttribI1i, isCallValid, context, index, x);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI1iv(GLuint index, const GLint *v)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI1iv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
            CID(context), index, (uintptr_t)v);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI1iv(context->getPrivateState(),
                                        context->getMutableErrorSetForValidation(),
                                        angle::EntryPoint::GLVertexAttribI1iv, index, v));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI1iv(context->getMutablePrivateState(),
                                             context->getMutablePrivateStateCache(), index, v);
          }
          ANGLE_CAPTURE_GL(VertexAttribI1iv, isCallValid, context, index, v);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI1ui(GLuint index, GLuint x)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI1ui, "context = %d, index = %u, x = %u", CID(context), index, x);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI1ui(context->getPrivateState(),
                                        context->getMutableErrorSetForValidation(),
                                        angle::EntryPoint::GLVertexAttribI1ui, index, x));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI1ui(context->getMutablePrivateState(),
                                             context->getMutablePrivateStateCache(), index, x);
          }
          ANGLE_CAPTURE_GL(VertexAttribI1ui, isCallValid, context, index, x);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI1uiv(GLuint index, const GLuint *v)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI1uiv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
            CID(context), index, (uintptr_t)v);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI1uiv(context->getPrivateState(),
                                         context->getMutableErrorSetForValidation(),
                                         angle::EntryPoint::GLVertexAttribI1uiv, index, v));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI1uiv(context->getMutablePrivateState(),
                                              context->getMutablePrivateStateCache(), index, v);
          }
          ANGLE_CAPTURE_GL(VertexAttribI1uiv, isCallValid, context, index, v);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI2i(GLuint index, GLint x, GLint y)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI2i, "context = %d, index = %u, x = %d, y = %d", CID(context),
            index, x, y);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI2i(context->getPrivateState(),
                                       context->getMutableErrorSetForValidation(),
                                       angle::EntryPoint::GLVertexAttribI2i, index, x, y));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI2i(context->getMutablePrivateState(),
                                            context->getMutablePrivateStateCache(), index, x, y);
          }
          ANGLE_CAPTURE_GL(VertexAttribI2i, isCallValid, context, index, x, y);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI2iv(GLuint index, const GLint *v)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI2iv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
            CID(context), index, (uintptr_t)v);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI2iv(context->getPrivateState(),
                                        context->getMutableErrorSetForValidation(),
                                        angle::EntryPoint::GLVertexAttribI2iv, index, v));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI2iv(context->getMutablePrivateState(),
                                             context->getMutablePrivateStateCache(), index, v);
          }
          ANGLE_CAPTURE_GL(VertexAttribI2iv, isCallValid, context, index, v);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI2ui(GLuint index, GLuint x, GLuint y)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI2ui, "context = %d, index = %u, x = %u, y = %u", CID(context),
            index, x, y);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI2ui(context->getPrivateState(),
                                        context->getMutableErrorSetForValidation(),
                                        angle::EntryPoint::GLVertexAttribI2ui, index, x, y));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI2ui(context->getMutablePrivateState(),
                                             context->getMutablePrivateStateCache(), index, x, y);
          }
          ANGLE_CAPTURE_GL(VertexAttribI2ui, isCallValid, context, index, x, y);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI2uiv(GLuint index, const GLuint *v)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI2uiv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
            CID(context), index, (uintptr_t)v);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI2uiv(context->getPrivateState(),
                                         context->getMutableErrorSetForValidation(),
                                         angle::EntryPoint::GLVertexAttribI2uiv, index, v));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI2uiv(context->getMutablePrivateState(),
                                              context->getMutablePrivateStateCache(), index, v);
          }
          ANGLE_CAPTURE_GL(VertexAttribI2uiv, isCallValid, context, index, v);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI3i, "context = %d, index = %u, x = %d, y = %d, z = %d",
            CID(context), index, x, y, z);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI3i(context->getPrivateState(),
                                       context->getMutableErrorSetForValidation(),
                                       angle::EntryPoint::GLVertexAttribI3i, index, x, y, z));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI3i(context->getMutablePrivateState(),
                                            context->getMutablePrivateStateCache(), index, x, y, z);
          }
          ANGLE_CAPTURE_GL(VertexAttribI3i, isCallValid, context, index, x, y, z);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI3iv(GLuint index, const GLint *v)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI3iv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
            CID(context), index, (uintptr_t)v);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI3iv(context->getPrivateState(),
                                        context->getMutableErrorSetForValidation(),
                                        angle::EntryPoint::GLVertexAttribI3iv, index, v));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI3iv(context->getMutablePrivateState(),
                                             context->getMutablePrivateStateCache(), index, v);
          }
          ANGLE_CAPTURE_GL(VertexAttribI3iv, isCallValid, context, index, v);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI3ui, "context = %d, index = %u, x = %u, y = %u, z = %u",
            CID(context), index, x, y, z);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI3ui(context->getPrivateState(),
                                        context->getMutableErrorSetForValidation(),
                                        angle::EntryPoint::GLVertexAttribI3ui, index, x, y, z));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI3ui(context->getMutablePrivateState(),
                                             context->getMutablePrivateStateCache(), index, x, y, z);
          }
          ANGLE_CAPTURE_GL(VertexAttribI3ui, isCallValid, context, index, x, y, z);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI3uiv(GLuint index, const GLuint *v)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI3uiv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
            CID(context), index, (uintptr_t)v);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI3uiv(context->getPrivateState(),
                                         context->getMutableErrorSetForValidation(),
                                         angle::EntryPoint::GLVertexAttribI3uiv, index, v));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI3uiv(context->getMutablePrivateState(),
                                              context->getMutablePrivateStateCache(), index, v);
          }
          ANGLE_CAPTURE_GL(VertexAttribI3uiv, isCallValid, context, index, v);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI4bv(GLuint index, const GLbyte *v)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI4bv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
            CID(context), index, (uintptr_t)v);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI4bv(context->getPrivateState(),
                                        context->getMutableErrorSetForValidation(),
                                        angle::EntryPoint::GLVertexAttribI4bv, index, v));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI4bv(context->getMutablePrivateState(),
                                             context->getMutablePrivateStateCache(), index, v);
          }
          ANGLE_CAPTURE_GL(VertexAttribI4bv, isCallValid, context, index, v);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI4sv(GLuint index, const GLshort *v)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI4sv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
            CID(context), index, (uintptr_t)v);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI4sv(context->getPrivateState(),
                                        context->getMutableErrorSetForValidation(),
                                        angle::EntryPoint::GLVertexAttribI4sv, index, v));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI4sv(context->getMutablePrivateState(),
                                             context->getMutablePrivateStateCache(), index, v);
          }
          ANGLE_CAPTURE_GL(VertexAttribI4sv, isCallValid, context, index, v);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI4ubv(GLuint index, const GLubyte *v)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI4ubv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
            CID(context), index, (uintptr_t)v);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI4ubv(context->getPrivateState(),
                                         context->getMutableErrorSetForValidation(),
                                         angle::EntryPoint::GLVertexAttribI4ubv, index, v));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI4ubv(context->getMutablePrivateState(),
                                              context->getMutablePrivateStateCache(), index, v);
          }
          ANGLE_CAPTURE_GL(VertexAttribI4ubv, isCallValid, context, index, v);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribI4usv(GLuint index, const GLushort *v)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribI4usv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
            CID(context), index, (uintptr_t)v);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribI4usv(context->getPrivateState(),
                                         context->getMutableErrorSetForValidation(),
                                         angle::EntryPoint::GLVertexAttribI4usv, index, v));
          if (isCallValid)
          {
              ContextPrivateVertexAttribI4usv(context->getMutablePrivateState(),
                                              context->getMutablePrivateStateCache(), index, v);
          }
          ANGLE_CAPTURE_GL(VertexAttribI4usv, isCallValid, context, index, v);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  // GL 3.1
  void GL_APIENTRY GL_GetActiveUniformName(GLuint program,
                                           GLuint uniformIndex,
                                           GLsizei bufSize,
                                           GLsizei *length,
                                           GLchar *uniformName)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLGetActiveUniformName,
            "context = %d, program = %u, uniformIndex = %u, bufSize = %d, length = 0x%016" PRIxPTR
            ", uniformName = 0x%016" PRIxPTR "",
            CID(context), program, uniformIndex, bufSize, (uintptr_t)length, (uintptr_t)uniformName);
  
      if (context)
      {
          ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid = (context->skipValidation() ||
                              ValidateGetActiveUniformName(
                                  context, angle::EntryPoint::GLGetActiveUniformName, programPacked,
                                  uniformIndex, bufSize, length, uniformName));
          if (isCallValid)
          {
              context->getActiveUniformName(programPacked, uniformIndex, bufSize, length,
                                            uniformName);
          }
          ANGLE_CAPTURE_GL(GetActiveUniformName, isCallValid, context, programPacked, uniformIndex,
                           bufSize, length, uniformName);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_PrimitiveRestartIndex(GLuint index)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLPrimitiveRestartIndex, "context = %d, index = %u", CID(context), index);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLPrimitiveRestartIndex) &&
                ValidatePrimitiveRestartIndex(context, angle::EntryPoint::GLPrimitiveRestartIndex,
                                              index)));
          if (isCallValid)
          {
              context->primitiveRestartIndex(index);
          }
          ANGLE_CAPTURE_GL(PrimitiveRestartIndex, isCallValid, context, index);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  // GL 3.2
  void GL_APIENTRY GL_MultiDrawElementsBaseVertex(GLenum mode,
                                                  const GLsizei *count,
                                                  GLenum type,
                                                  const void *const *indices,
                                                  GLsizei drawcount,
                                                  const GLint *basevertex)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLMultiDrawElementsBaseVertex,
            "context = %d, mode = %s, count = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR
            ", drawcount = %d, basevertex = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), (uintptr_t)count,
            GLenumToString(BigGLEnum::DrawElementsType, type), (uintptr_t)indices, drawcount,
            (uintptr_t)basevertex);
  
      if (context)
      {
          PrimitiveMode modePacked    = PackParam<PrimitiveMode>(mode);
          DrawElementsType typePacked = PackParam<DrawElementsType>(type);
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLMultiDrawElementsBaseVertex) &&
                ValidateMultiDrawElementsBaseVertex(
                    context, angle::EntryPoint::GLMultiDrawElementsBaseVertex, modePacked, count,
                    typePacked, indices, drawcount, basevertex)));
          if (isCallValid)
          {
              context->multiDrawElementsBaseVertex(modePacked, count, typePacked, indices, drawcount,
                                                   basevertex);
          }
          ANGLE_CAPTURE_GL(MultiDrawElementsBaseVertex, isCallValid, context, modePacked, count,
                           typePacked, indices, drawcount, basevertex);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_ProvokingVertex(GLenum mode)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLProvokingVertex, "context = %d, mode = %s", CID(context),
            GLenumToString(BigGLEnum::VertexProvokingMode, mode));
  
      if (context)
      {
          ProvokingVertexConvention modePacked = PackParam<ProvokingVertexConvention>(mode);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLProvokingVertex) &&
                ValidateProvokingVertex(context->getPrivateState(),
                                        context->getMutableErrorSetForValidation(),
                                        angle::EntryPoint::GLProvokingVertex, modePacked)));
          if (isCallValid)
          {
              ContextPrivateProvokingVertex(context->getMutablePrivateState(),
                                            context->getMutablePrivateStateCache(), modePacked);
          }
          ANGLE_CAPTURE_GL(ProvokingVertex, isCallValid, context, modePacked);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_TexImage2DMultisample(GLenum target,
                                            GLsizei samples,
                                            GLenum internalformat,
                                            GLsizei width,
                                            GLsizei height,
                                            GLboolean fixedsamplelocations)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLTexImage2DMultisample,
            "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, "
            "fixedsamplelocations = %s",
            CID(context), GLenumToString(BigGLEnum::TextureTarget, target), samples,
            GLenumToString(BigGLEnum::InternalFormat, internalformat), width, height,
            GLbooleanToString(fixedsamplelocations));
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLTexImage2DMultisample) &&
                ValidateTexImage2DMultisample(context, angle::EntryPoint::GLTexImage2DMultisample,
                                              target, samples, internalformat, width, height,
                                              fixedsamplelocations)));
          if (isCallValid)
          {
              context->texImage2DMultisample(target, samples, internalformat, width, height,
                                             fixedsamplelocations);
          }
          ANGLE_CAPTURE_GL(TexImage2DMultisample, isCallValid, context, target, samples,
                           internalformat, width, height, fixedsamplelocations);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
  }
  
  void GL_APIENTRY GL_TexImage3DMultisample(GLenum target,
                                            GLsizei samples,
                                            GLenum internalformat,
                                            GLsizei width,
                                            GLsizei height,
                                            GLsizei depth,
                                            GLboolean fixedsamplelocations)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLTexImage3DMultisample,
            "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, "
            "depth = %d, fixedsamplelocations = %s",
            CID(context), GLenumToString(BigGLEnum::TextureTarget, target), samples,
            GLenumToString(BigGLEnum::InternalFormat, internalformat), width, height, depth,
            GLbooleanToString(fixedsamplelocations));
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLTexImage3DMultisample) &&
                ValidateTexImage3DMultisample(context, angle::EntryPoint::GLTexImage3DMultisample,
                                              target, samples, internalformat, width, height, depth,
                                              fixedsamplelocations)));
          if (isCallValid)
          {
              context->texImage3DMultisample(target, samples, internalformat, width, height, depth,
                                             fixedsamplelocations);
          }
          ANGLE_CAPTURE_GL(TexImage3DMultisample, isCallValid, context, target, samples,
                           internalformat, width, height, depth, fixedsamplelocations);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      egl::Display::GetCurrentThreadUnlockedTailCall()->run(nullptr);
  }
  
  // GL 3.3
  void GL_APIENTRY GL_BindFragDataLocationIndexed(GLuint program,
                                                  GLuint colorNumber,
                                                  GLuint index,
                                                  const GLchar *name)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLBindFragDataLocationIndexed,
            "context = %d, program = %u, colorNumber = %u, index = %u, name = 0x%016" PRIxPTR "",
            CID(context), program, colorNumber, index, (uintptr_t)name);
  
      if (context)
      {
          ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLBindFragDataLocationIndexed) &&
                ValidateBindFragDataLocationIndexed(context,
                                                    angle::EntryPoint::GLBindFragDataLocationIndexed,
                                                    programPacked, colorNumber, index, name)));
          if (isCallValid)
          {
              context->bindFragDataLocationIndexed(programPacked, colorNumber, index, name);
          }
          ANGLE_CAPTURE_GL(BindFragDataLocationIndexed, isCallValid, context, programPacked,
                           colorNumber, index, name);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_ColorP3ui(GLenum type, GLuint color)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLColorP3ui, "context = %d, type = %s, color = %u", CID(context),
            GLenumToString(BigGLEnum::ColorPointerType, type), color);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLColorP3ui) &&
                ValidateColorP3ui(context, angle::EntryPoint::GLColorP3ui, type, color)));
          if (isCallValid)
          {
              context->colorP3ui(type, color);
          }
          ANGLE_CAPTURE_GL(ColorP3ui, isCallValid, context, type, color);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_ColorP3uiv(GLenum type, const GLuint *color)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLColorP3uiv, "context = %d, type = %s, color = 0x%016" PRIxPTR "", CID(context),
            GLenumToString(BigGLEnum::ColorPointerType, type), (uintptr_t)color);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLColorP3uiv) &&
                ValidateColorP3uiv(context, angle::EntryPoint::GLColorP3uiv, type, color)));
          if (isCallValid)
          {
              context->colorP3uiv(type, color);
          }
          ANGLE_CAPTURE_GL(ColorP3uiv, isCallValid, context, type, color);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_ColorP4ui(GLenum type, GLuint color)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLColorP4ui, "context = %d, type = %s, color = %u", CID(context),
            GLenumToString(BigGLEnum::ColorPointerType, type), color);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLColorP4ui) &&
                ValidateColorP4ui(context, angle::EntryPoint::GLColorP4ui, type, color)));
          if (isCallValid)
          {
              context->colorP4ui(type, color);
          }
          ANGLE_CAPTURE_GL(ColorP4ui, isCallValid, context, type, color);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_ColorP4uiv(GLenum type, const GLuint *color)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLColorP4uiv, "context = %d, type = %s, color = 0x%016" PRIxPTR "", CID(context),
            GLenumToString(BigGLEnum::ColorPointerType, type), (uintptr_t)color);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLColorP4uiv) &&
                ValidateColorP4uiv(context, angle::EntryPoint::GLColorP4uiv, type, color)));
          if (isCallValid)
          {
              context->colorP4uiv(type, color);
          }
          ANGLE_CAPTURE_GL(ColorP4uiv, isCallValid, context, type, color);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  GLint GL_APIENTRY GL_GetFragDataIndex(GLuint program, const GLchar *name)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLGetFragDataIndex, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
            CID(context), program, (uintptr_t)name);
  
      GLint returnValue;
      if (context)
      {
          ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid = (context->skipValidation() ||
                              ValidateGetFragDataIndex(context, angle::EntryPoint::GLGetFragDataIndex,
                                                       programPacked, name));
          if (isCallValid)
          {
              returnValue = context->getFragDataIndex(programPacked, name);
          }
          else
          {
              returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataIndex, GLint>();
          }
          ANGLE_CAPTURE_GL(GetFragDataIndex, isCallValid, context, programPacked, name, returnValue);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
          returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataIndex, GLint>();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
      return returnValue;
  }
  
  void GL_APIENTRY GL_GetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
  {
      Context *context = GetGlobalContext();
      EVENT(context, GLGetQueryObjecti64v,
            "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
            GLenumToString(BigGLEnum::QueryObjectParameterName, pname), (uintptr_t)params);
  
      if (context)
      {
          QueryID idPacked = PackParam<QueryID>(id);
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               ValidateGetQueryObjecti64v(context, angle::EntryPoint::GLGetQueryObjecti64v, idPacked,
                                          pname, params));
          if (isCallValid)
          {
              context->getQueryObjecti64v(idPacked, pname, params);
          }
          ANGLE_CAPTURE_GL(GetQueryObjecti64v, isCallValid, context, idPacked, pname, params);
      }
      else
      {
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_GetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLGetQueryObjectui64v,
            "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id,
            GLenumToString(BigGLEnum::QueryObjectParameterName, pname), (uintptr_t)params);
  
      if (context)
      {
          QueryID idPacked = PackParam<QueryID>(id);
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               ValidateGetQueryObjectui64v(context, angle::EntryPoint::GLGetQueryObjectui64v,
                                           idPacked, pname, params));
          if (isCallValid)
          {
              context->getQueryObjectui64v(idPacked, pname, params);
          }
          ANGLE_CAPTURE_GL(GetQueryObjectui64v, isCallValid, context, idPacked, pname, params);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_MultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLMultiTexCoordP1ui, "context = %d, texture = %s, type = %s, coords = %u",
            CID(context), GLenumToString(BigGLEnum::TextureUnit, texture),
            GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLMultiTexCoordP1ui) &&
                ValidateMultiTexCoordP1ui(context, angle::EntryPoint::GLMultiTexCoordP1ui, texture,
                                          type, coords)));
          if (isCallValid)
          {
              context->multiTexCoordP1ui(texture, type, coords);
          }
          ANGLE_CAPTURE_GL(MultiTexCoordP1ui, isCallValid, context, texture, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_MultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLMultiTexCoordP1uiv,
            "context = %d, texture = %s, type = %s, coords = 0x%016" PRIxPTR "", CID(context),
            GLenumToString(BigGLEnum::TextureUnit, texture),
            GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLMultiTexCoordP1uiv) &&
                ValidateMultiTexCoordP1uiv(context, angle::EntryPoint::GLMultiTexCoordP1uiv, texture,
                                           type, coords)));
          if (isCallValid)
          {
              context->multiTexCoordP1uiv(texture, type, coords);
          }
          ANGLE_CAPTURE_GL(MultiTexCoordP1uiv, isCallValid, context, texture, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_MultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLMultiTexCoordP2ui, "context = %d, texture = %s, type = %s, coords = %u",
            CID(context), GLenumToString(BigGLEnum::TextureUnit, texture),
            GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLMultiTexCoordP2ui) &&
                ValidateMultiTexCoordP2ui(context, angle::EntryPoint::GLMultiTexCoordP2ui, texture,
                                          type, coords)));
          if (isCallValid)
          {
              context->multiTexCoordP2ui(texture, type, coords);
          }
          ANGLE_CAPTURE_GL(MultiTexCoordP2ui, isCallValid, context, texture, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_MultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLMultiTexCoordP2uiv,
            "context = %d, texture = %s, type = %s, coords = 0x%016" PRIxPTR "", CID(context),
            GLenumToString(BigGLEnum::TextureUnit, texture),
            GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLMultiTexCoordP2uiv) &&
                ValidateMultiTexCoordP2uiv(context, angle::EntryPoint::GLMultiTexCoordP2uiv, texture,
                                           type, coords)));
          if (isCallValid)
          {
              context->multiTexCoordP2uiv(texture, type, coords);
          }
          ANGLE_CAPTURE_GL(MultiTexCoordP2uiv, isCallValid, context, texture, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_MultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLMultiTexCoordP3ui, "context = %d, texture = %s, type = %s, coords = %u",
            CID(context), GLenumToString(BigGLEnum::TextureUnit, texture),
            GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLMultiTexCoordP3ui) &&
                ValidateMultiTexCoordP3ui(context, angle::EntryPoint::GLMultiTexCoordP3ui, texture,
                                          type, coords)));
          if (isCallValid)
          {
              context->multiTexCoordP3ui(texture, type, coords);
          }
          ANGLE_CAPTURE_GL(MultiTexCoordP3ui, isCallValid, context, texture, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_MultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLMultiTexCoordP3uiv,
            "context = %d, texture = %s, type = %s, coords = 0x%016" PRIxPTR "", CID(context),
            GLenumToString(BigGLEnum::TextureUnit, texture),
            GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLMultiTexCoordP3uiv) &&
                ValidateMultiTexCoordP3uiv(context, angle::EntryPoint::GLMultiTexCoordP3uiv, texture,
                                           type, coords)));
          if (isCallValid)
          {
              context->multiTexCoordP3uiv(texture, type, coords);
          }
          ANGLE_CAPTURE_GL(MultiTexCoordP3uiv, isCallValid, context, texture, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_MultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLMultiTexCoordP4ui, "context = %d, texture = %s, type = %s, coords = %u",
            CID(context), GLenumToString(BigGLEnum::TextureUnit, texture),
            GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLMultiTexCoordP4ui) &&
                ValidateMultiTexCoordP4ui(context, angle::EntryPoint::GLMultiTexCoordP4ui, texture,
                                          type, coords)));
          if (isCallValid)
          {
              context->multiTexCoordP4ui(texture, type, coords);
          }
          ANGLE_CAPTURE_GL(MultiTexCoordP4ui, isCallValid, context, texture, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_MultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLMultiTexCoordP4uiv,
            "context = %d, texture = %s, type = %s, coords = 0x%016" PRIxPTR "", CID(context),
            GLenumToString(BigGLEnum::TextureUnit, texture),
            GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLMultiTexCoordP4uiv) &&
                ValidateMultiTexCoordP4uiv(context, angle::EntryPoint::GLMultiTexCoordP4uiv, texture,
                                           type, coords)));
          if (isCallValid)
          {
              context->multiTexCoordP4uiv(texture, type, coords);
          }
          ANGLE_CAPTURE_GL(MultiTexCoordP4uiv, isCallValid, context, texture, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_NormalP3ui(GLenum type, GLuint coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLNormalP3ui, "context = %d, type = %s, coords = %u", CID(context),
            GLenumToString(BigGLEnum::NormalPointerType, type), coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLNormalP3ui) &&
                ValidateNormalP3ui(context, angle::EntryPoint::GLNormalP3ui, type, coords)));
          if (isCallValid)
          {
              context->normalP3ui(type, coords);
          }
          ANGLE_CAPTURE_GL(NormalP3ui, isCallValid, context, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_NormalP3uiv(GLenum type, const GLuint *coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLNormalP3uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(BigGLEnum::NormalPointerType, type), (uintptr_t)coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLNormalP3uiv) &&
                ValidateNormalP3uiv(context, angle::EntryPoint::GLNormalP3uiv, type, coords)));
          if (isCallValid)
          {
              context->normalP3uiv(type, coords);
          }
          ANGLE_CAPTURE_GL(NormalP3uiv, isCallValid, context, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_QueryCounter(GLuint id, GLenum target)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLQueryCounter, "context = %d, id = %u, target = %s", CID(context), id,
            GLenumToString(BigGLEnum::QueryCounterTarget, target));
  
      if (context)
      {
          QueryID idPacked       = PackParam<QueryID>(id);
          QueryType targetPacked = PackParam<QueryType>(target);
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLQueryCounter) &&
                ValidateQueryCounter(context, angle::EntryPoint::GLQueryCounter, idPacked,
                                     targetPacked)));
          if (isCallValid)
          {
              context->queryCounter(idPacked, targetPacked);
          }
          ANGLE_CAPTURE_GL(QueryCounter, isCallValid, context, idPacked, targetPacked);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_SecondaryColorP3ui(GLenum type, GLuint color)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLSecondaryColorP3ui, "context = %d, type = %s, color = %u", CID(context),
            GLenumToString(BigGLEnum::ColorPointerType, type), color);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLSecondaryColorP3ui) &&
                ValidateSecondaryColorP3ui(context, angle::EntryPoint::GLSecondaryColorP3ui, type,
                                           color)));
          if (isCallValid)
          {
              context->secondaryColorP3ui(type, color);
          }
          ANGLE_CAPTURE_GL(SecondaryColorP3ui, isCallValid, context, type, color);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_SecondaryColorP3uiv(GLenum type, const GLuint *color)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLSecondaryColorP3uiv, "context = %d, type = %s, color = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(BigGLEnum::ColorPointerType, type), (uintptr_t)color);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLSecondaryColorP3uiv) &&
                ValidateSecondaryColorP3uiv(context, angle::EntryPoint::GLSecondaryColorP3uiv, type,
                                            color)));
          if (isCallValid)
          {
              context->secondaryColorP3uiv(type, color);
          }
          ANGLE_CAPTURE_GL(SecondaryColorP3uiv, isCallValid, context, type, color);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_TexCoordP1ui(GLenum type, GLuint coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLTexCoordP1ui, "context = %d, type = %s, coords = %u", CID(context),
            GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLTexCoordP1ui) &&
                ValidateTexCoordP1ui(context, angle::EntryPoint::GLTexCoordP1ui, type, coords)));
          if (isCallValid)
          {
              context->texCoordP1ui(type, coords);
          }
          ANGLE_CAPTURE_GL(TexCoordP1ui, isCallValid, context, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_TexCoordP1uiv(GLenum type, const GLuint *coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLTexCoordP1uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLTexCoordP1uiv) &&
                ValidateTexCoordP1uiv(context, angle::EntryPoint::GLTexCoordP1uiv, type, coords)));
          if (isCallValid)
          {
              context->texCoordP1uiv(type, coords);
          }
          ANGLE_CAPTURE_GL(TexCoordP1uiv, isCallValid, context, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_TexCoordP2ui(GLenum type, GLuint coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLTexCoordP2ui, "context = %d, type = %s, coords = %u", CID(context),
            GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLTexCoordP2ui) &&
                ValidateTexCoordP2ui(context, angle::EntryPoint::GLTexCoordP2ui, type, coords)));
          if (isCallValid)
          {
              context->texCoordP2ui(type, coords);
          }
          ANGLE_CAPTURE_GL(TexCoordP2ui, isCallValid, context, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_TexCoordP2uiv(GLenum type, const GLuint *coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLTexCoordP2uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLTexCoordP2uiv) &&
                ValidateTexCoordP2uiv(context, angle::EntryPoint::GLTexCoordP2uiv, type, coords)));
          if (isCallValid)
          {
              context->texCoordP2uiv(type, coords);
          }
          ANGLE_CAPTURE_GL(TexCoordP2uiv, isCallValid, context, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_TexCoordP3ui(GLenum type, GLuint coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLTexCoordP3ui, "context = %d, type = %s, coords = %u", CID(context),
            GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLTexCoordP3ui) &&
                ValidateTexCoordP3ui(context, angle::EntryPoint::GLTexCoordP3ui, type, coords)));
          if (isCallValid)
          {
              context->texCoordP3ui(type, coords);
          }
          ANGLE_CAPTURE_GL(TexCoordP3ui, isCallValid, context, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_TexCoordP3uiv(GLenum type, const GLuint *coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLTexCoordP3uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLTexCoordP3uiv) &&
                ValidateTexCoordP3uiv(context, angle::EntryPoint::GLTexCoordP3uiv, type, coords)));
          if (isCallValid)
          {
              context->texCoordP3uiv(type, coords);
          }
          ANGLE_CAPTURE_GL(TexCoordP3uiv, isCallValid, context, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_TexCoordP4ui(GLenum type, GLuint coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLTexCoordP4ui, "context = %d, type = %s, coords = %u", CID(context),
            GLenumToString(BigGLEnum::TexCoordPointerType, type), coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLTexCoordP4ui) &&
                ValidateTexCoordP4ui(context, angle::EntryPoint::GLTexCoordP4ui, type, coords)));
          if (isCallValid)
          {
              context->texCoordP4ui(type, coords);
          }
          ANGLE_CAPTURE_GL(TexCoordP4ui, isCallValid, context, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_TexCoordP4uiv(GLenum type, const GLuint *coords)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLTexCoordP4uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLTexCoordP4uiv) &&
                ValidateTexCoordP4uiv(context, angle::EntryPoint::GLTexCoordP4uiv, type, coords)));
          if (isCallValid)
          {
              context->texCoordP4uiv(type, coords);
          }
          ANGLE_CAPTURE_GL(TexCoordP4uiv, isCallValid, context, type, coords);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribP1ui,
            "context = %d, index = %u, type = %s, normalized = %s, value = %u", CID(context), index,
            GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized),
            value);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribP1ui(
                   context->getPrivateState(), context->getMutableErrorSetForValidation(),
                   angle::EntryPoint::GLVertexAttribP1ui, index, type, normalized, value));
          if (isCallValid)
          {
              ContextPrivateVertexAttribP1ui(context->getMutablePrivateState(),
                                             context->getMutablePrivateStateCache(), index, type,
                                             normalized, value);
          }
          ANGLE_CAPTURE_GL(VertexAttribP1ui, isCallValid, context, index, type, normalized, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribP1uiv(GLuint index,
                                        GLenum type,
                                        GLboolean normalized,
                                        const GLuint *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribP1uiv,
            "context = %d, index = %u, type = %s, normalized = %s, value = 0x%016" PRIxPTR "",
            CID(context), index, GLenumToString(BigGLEnum::VertexAttribPointerType, type),
            GLbooleanToString(normalized), (uintptr_t)value);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribP1uiv(
                   context->getPrivateState(), context->getMutableErrorSetForValidation(),
                   angle::EntryPoint::GLVertexAttribP1uiv, index, type, normalized, value));
          if (isCallValid)
          {
              ContextPrivateVertexAttribP1uiv(context->getMutablePrivateState(),
                                              context->getMutablePrivateStateCache(), index, type,
                                              normalized, value);
          }
          ANGLE_CAPTURE_GL(VertexAttribP1uiv, isCallValid, context, index, type, normalized, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribP2ui,
            "context = %d, index = %u, type = %s, normalized = %s, value = %u", CID(context), index,
            GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized),
            value);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribP2ui(
                   context->getPrivateState(), context->getMutableErrorSetForValidation(),
                   angle::EntryPoint::GLVertexAttribP2ui, index, type, normalized, value));
          if (isCallValid)
          {
              ContextPrivateVertexAttribP2ui(context->getMutablePrivateState(),
                                             context->getMutablePrivateStateCache(), index, type,
                                             normalized, value);
          }
          ANGLE_CAPTURE_GL(VertexAttribP2ui, isCallValid, context, index, type, normalized, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribP2uiv(GLuint index,
                                        GLenum type,
                                        GLboolean normalized,
                                        const GLuint *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribP2uiv,
            "context = %d, index = %u, type = %s, normalized = %s, value = 0x%016" PRIxPTR "",
            CID(context), index, GLenumToString(BigGLEnum::VertexAttribPointerType, type),
            GLbooleanToString(normalized), (uintptr_t)value);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribP2uiv(
                   context->getPrivateState(), context->getMutableErrorSetForValidation(),
                   angle::EntryPoint::GLVertexAttribP2uiv, index, type, normalized, value));
          if (isCallValid)
          {
              ContextPrivateVertexAttribP2uiv(context->getMutablePrivateState(),
                                              context->getMutablePrivateStateCache(), index, type,
                                              normalized, value);
          }
          ANGLE_CAPTURE_GL(VertexAttribP2uiv, isCallValid, context, index, type, normalized, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribP3ui,
            "context = %d, index = %u, type = %s, normalized = %s, value = %u", CID(context), index,
            GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized),
            value);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribP3ui(
                   context->getPrivateState(), context->getMutableErrorSetForValidation(),
                   angle::EntryPoint::GLVertexAttribP3ui, index, type, normalized, value));
          if (isCallValid)
          {
              ContextPrivateVertexAttribP3ui(context->getMutablePrivateState(),
                                             context->getMutablePrivateStateCache(), index, type,
                                             normalized, value);
          }
          ANGLE_CAPTURE_GL(VertexAttribP3ui, isCallValid, context, index, type, normalized, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribP3uiv(GLuint index,
                                        GLenum type,
                                        GLboolean normalized,
                                        const GLuint *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribP3uiv,
            "context = %d, index = %u, type = %s, normalized = %s, value = 0x%016" PRIxPTR "",
            CID(context), index, GLenumToString(BigGLEnum::VertexAttribPointerType, type),
            GLbooleanToString(normalized), (uintptr_t)value);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribP3uiv(
                   context->getPrivateState(), context->getMutableErrorSetForValidation(),
                   angle::EntryPoint::GLVertexAttribP3uiv, index, type, normalized, value));
          if (isCallValid)
          {
              ContextPrivateVertexAttribP3uiv(context->getMutablePrivateState(),
                                              context->getMutablePrivateStateCache(), index, type,
                                              normalized, value);
          }
          ANGLE_CAPTURE_GL(VertexAttribP3uiv, isCallValid, context, index, type, normalized, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribP4ui,
            "context = %d, index = %u, type = %s, normalized = %s, value = %u", CID(context), index,
            GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized),
            value);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribP4ui(
                   context->getPrivateState(), context->getMutableErrorSetForValidation(),
                   angle::EntryPoint::GLVertexAttribP4ui, index, type, normalized, value));
          if (isCallValid)
          {
              ContextPrivateVertexAttribP4ui(context->getMutablePrivateState(),
                                             context->getMutablePrivateStateCache(), index, type,
                                             normalized, value);
          }
          ANGLE_CAPTURE_GL(VertexAttribP4ui, isCallValid, context, index, type, normalized, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexAttribP4uiv(GLuint index,
                                        GLenum type,
                                        GLboolean normalized,
                                        const GLuint *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexAttribP4uiv,
            "context = %d, index = %u, type = %s, normalized = %s, value = 0x%016" PRIxPTR "",
            CID(context), index, GLenumToString(BigGLEnum::VertexAttribPointerType, type),
            GLbooleanToString(normalized), (uintptr_t)value);
  
      if (context)
      {
          bool isCallValid =
              (context->skipValidation() ||
               ValidateVertexAttribP4uiv(
                   context->getPrivateState(), context->getMutableErrorSetForValidation(),
                   angle::EntryPoint::GLVertexAttribP4uiv, index, type, normalized, value));
          if (isCallValid)
          {
              ContextPrivateVertexAttribP4uiv(context->getMutablePrivateState(),
                                              context->getMutablePrivateStateCache(), index, type,
                                              normalized, value);
          }
          ANGLE_CAPTURE_GL(VertexAttribP4uiv, isCallValid, context, index, type, normalized, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexP2ui(GLenum type, GLuint value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexP2ui, "context = %d, type = %s, value = %u", CID(context),
            GLenumToString(BigGLEnum::VertexPointerType, type), value);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLVertexP2ui) &&
                ValidateVertexP2ui(context, angle::EntryPoint::GLVertexP2ui, type, value)));
          if (isCallValid)
          {
              context->vertexP2ui(type, value);
          }
          ANGLE_CAPTURE_GL(VertexP2ui, isCallValid, context, type, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexP2uiv(GLenum type, const GLuint *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexP2uiv, "context = %d, type = %s, value = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(BigGLEnum::VertexPointerType, type), (uintptr_t)value);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLVertexP2uiv) &&
                ValidateVertexP2uiv(context, angle::EntryPoint::GLVertexP2uiv, type, value)));
          if (isCallValid)
          {
              context->vertexP2uiv(type, value);
          }
          ANGLE_CAPTURE_GL(VertexP2uiv, isCallValid, context, type, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexP3ui(GLenum type, GLuint value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexP3ui, "context = %d, type = %s, value = %u", CID(context),
            GLenumToString(BigGLEnum::VertexPointerType, type), value);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLVertexP3ui) &&
                ValidateVertexP3ui(context, angle::EntryPoint::GLVertexP3ui, type, value)));
          if (isCallValid)
          {
              context->vertexP3ui(type, value);
          }
          ANGLE_CAPTURE_GL(VertexP3ui, isCallValid, context, type, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexP3uiv(GLenum type, const GLuint *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexP3uiv, "context = %d, type = %s, value = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(BigGLEnum::VertexPointerType, type), (uintptr_t)value);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLVertexP3uiv) &&
                ValidateVertexP3uiv(context, angle::EntryPoint::GLVertexP3uiv, type, value)));
          if (isCallValid)
          {
              context->vertexP3uiv(type, value);
          }
          ANGLE_CAPTURE_GL(VertexP3uiv, isCallValid, context, type, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexP4ui(GLenum type, GLuint value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexP4ui, "context = %d, type = %s, value = %u", CID(context),
            GLenumToString(BigGLEnum::VertexPointerType, type), value);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLVertexP4ui) &&
                ValidateVertexP4ui(context, angle::EntryPoint::GLVertexP4ui, type, value)));
          if (isCallValid)
          {
              context->vertexP4ui(type, value);
          }
          ANGLE_CAPTURE_GL(VertexP4ui, isCallValid, context, type, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  void GL_APIENTRY GL_VertexP4uiv(GLenum type, const GLuint *value)
  {
      Context *context = GetValidGlobalContext();
      EVENT(context, GLVertexP4uiv, "context = %d, type = %s, value = 0x%016" PRIxPTR "",
            CID(context), GLenumToString(BigGLEnum::VertexPointerType, type), (uintptr_t)value);
  
      if (context)
      {
          SCOPED_SHARE_CONTEXT_LOCK(context);
          bool isCallValid =
              (context->skipValidation() ||
               (ValidatePixelLocalStorageInactive(context->getPrivateState(),
                                                  context->getMutableErrorSetForValidation(),
                                                  angle::EntryPoint::GLVertexP4uiv) &&
                ValidateVertexP4uiv(context, angle::EntryPoint::GLVertexP4uiv, type, value)));
          if (isCallValid)
          {
              context->vertexP4uiv(type, value);
          }
          ANGLE_CAPTURE_GL(VertexP4uiv, isCallValid, context, type, value);
      }
      else
      {
          GenerateContextLostErrorOnCurrentGlobalContext();
      }
      ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
  }
  
  }  // extern "C"
  

Download