Add DCHECK for nullptr in gl bindings

ui/gl/gl_bindings_autogen_gl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // This file is auto-generated from
 // ui/gl/generate_bindings.py
 // It's formatted by clang-format using chromium coding style:
 //    clang-format -i -style=chromium filename
 // DO NOT EDIT!
 
@@ skipping 2018 matching lines @@
 
   if (g_debugBindingsInitialized)
     InitializeDebugBindings();
 }
 
 extern "C" {
 
 static void GL_BINDING_CALL Debug_glActiveTexture(GLenum texture) {
   GL_SERVICE_LOG("glActiveTexture"
                  << "(" << GLEnums::GetStringEnum(texture) << ")");
+  DCHECK(g_driver_gl.debug_fn.glActiveTextureFn != nullptr);
   g_driver_gl.debug_fn.glActiveTextureFn(texture);
 }
 
 static void GL_BINDING_CALL Debug_glApplyFramebufferAttachmentCMAAINTEL(void) {
   GL_SERVICE_LOG("glApplyFramebufferAttachmentCMAAINTEL"
                  << "("
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glApplyFramebufferAttachmentCMAAINTELFn !=
+         nullptr);
   g_driver_gl.debug_fn.glApplyFramebufferAttachmentCMAAINTELFn();
 }
 
 static void GL_BINDING_CALL Debug_glAttachShader(GLuint program,
                                                  GLuint shader) {
   GL_SERVICE_LOG("glAttachShader"
                  << "(" << program << ", " << shader << ")");
+  DCHECK(g_driver_gl.debug_fn.glAttachShaderFn != nullptr);
   g_driver_gl.debug_fn.glAttachShaderFn(program, shader);
 }
 
 static void GL_BINDING_CALL Debug_glBeginQuery(GLenum target, GLuint id) {
   GL_SERVICE_LOG("glBeginQuery"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << id << ")");
+  DCHECK(g_driver_gl.debug_fn.glBeginQueryFn != nullptr);
   g_driver_gl.debug_fn.glBeginQueryFn(target, id);
 }
 
 static void GL_BINDING_CALL
 Debug_glBeginTransformFeedback(GLenum primitiveMode) {
   GL_SERVICE_LOG("glBeginTransformFeedback"
                  << "(" << GLEnums::GetStringEnum(primitiveMode) << ")");
+  DCHECK(g_driver_gl.debug_fn.glBeginTransformFeedbackFn != nullptr);
   g_driver_gl.debug_fn.glBeginTransformFeedbackFn(primitiveMode);
 }
 
 static void GL_BINDING_CALL Debug_glBindAttribLocation(GLuint program,
                                                        GLuint index,
                                                        const char* name) {
   GL_SERVICE_LOG("glBindAttribLocation"
                  << "(" << program << ", " << index << ", " << name << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindAttribLocationFn != nullptr);
   g_driver_gl.debug_fn.glBindAttribLocationFn(program, index, name);
 }
 
 static void GL_BINDING_CALL Debug_glBindBuffer(GLenum target, GLuint buffer) {
   GL_SERVICE_LOG("glBindBuffer"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << buffer
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindBufferFn != nullptr);
   g_driver_gl.debug_fn.glBindBufferFn(target, buffer);
 }
 
 static void GL_BINDING_CALL Debug_glBindBufferBase(GLenum target,
                                                    GLuint index,
                                                    GLuint buffer) {
   GL_SERVICE_LOG("glBindBufferBase"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << index
                  << ", " << buffer << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindBufferBaseFn != nullptr);
   g_driver_gl.debug_fn.glBindBufferBaseFn(target, index, buffer);
 }
 
 static void GL_BINDING_CALL Debug_glBindBufferRange(GLenum target,
                                                     GLuint index,
                                                     GLuint buffer,
                                                     GLintptr offset,
                                                     GLsizeiptr size) {
   GL_SERVICE_LOG("glBindBufferRange"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << index
                  << ", " << buffer << ", " << offset << ", " << size << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindBufferRangeFn != nullptr);
   g_driver_gl.debug_fn.glBindBufferRangeFn(target, index, buffer, offset, size);
 }
 
 static void GL_BINDING_CALL Debug_glBindFragDataLocation(GLuint program,
                                                          GLuint colorNumber,
                                                          const char* name) {
   GL_SERVICE_LOG("glBindFragDataLocation"
                  << "(" << program << ", " << colorNumber << ", " << name
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindFragDataLocationFn != nullptr);
   g_driver_gl.debug_fn.glBindFragDataLocationFn(program, colorNumber, name);
 }
 
 static void GL_BINDING_CALL
 Debug_glBindFragDataLocationIndexed(GLuint program,
                                     GLuint colorNumber,
                                     GLuint index,
                                     const char* name) {
   GL_SERVICE_LOG("glBindFragDataLocationIndexed"
                  << "(" << program << ", " << colorNumber << ", " << index
                  << ", " << name << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindFragDataLocationIndexedFn != nullptr);
   g_driver_gl.debug_fn.glBindFragDataLocationIndexedFn(program, colorNumber,
                                                        index, name);
 }
 
 static void GL_BINDING_CALL Debug_glBindFramebufferEXT(GLenum target,
                                                        GLuint framebuffer) {
   GL_SERVICE_LOG("glBindFramebufferEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << framebuffer
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindFramebufferEXTFn != nullptr);
   g_driver_gl.debug_fn.glBindFramebufferEXTFn(target, framebuffer);
 }
 
 static void GL_BINDING_CALL Debug_glBindImageTextureEXT(GLuint index,
                                                         GLuint texture,
                                                         GLint level,
                                                         GLboolean layered,
                                                         GLint layer,
                                                         GLenum access,
                                                         GLint format) {
   GL_SERVICE_LOG("glBindImageTextureEXT"
                  << "(" << index << ", " << texture << ", " << level << ", "
                  << GLEnums::GetStringBool(layered) << ", " << layer << ", "
                  << GLEnums::GetStringEnum(access) << ", " << format << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindImageTextureEXTFn != nullptr);
   g_driver_gl.debug_fn.glBindImageTextureEXTFn(index, texture, level, layered,
                                                layer, access, format);
 }
 
 static void GL_BINDING_CALL Debug_glBindRenderbufferEXT(GLenum target,
                                                         GLuint renderbuffer) {
   GL_SERVICE_LOG("glBindRenderbufferEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << renderbuffer << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindRenderbufferEXTFn != nullptr);
   g_driver_gl.debug_fn.glBindRenderbufferEXTFn(target, renderbuffer);
 }
 
 static void GL_BINDING_CALL Debug_glBindSampler(GLuint unit, GLuint sampler) {
   GL_SERVICE_LOG("glBindSampler"
                  << "(" << unit << ", " << sampler << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindSamplerFn != nullptr);
   g_driver_gl.debug_fn.glBindSamplerFn(unit, sampler);
 }
 
 static void GL_BINDING_CALL Debug_glBindTexture(GLenum target, GLuint texture) {
   GL_SERVICE_LOG("glBindTexture"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << texture
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindTextureFn != nullptr);
   g_driver_gl.debug_fn.glBindTextureFn(target, texture);
 }
 
 static void GL_BINDING_CALL Debug_glBindTransformFeedback(GLenum target,
                                                           GLuint id) {
   GL_SERVICE_LOG("glBindTransformFeedback"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << id << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindTransformFeedbackFn != nullptr);
   g_driver_gl.debug_fn.glBindTransformFeedbackFn(target, id);
 }
 
 static void GL_BINDING_CALL Debug_glBindVertexArrayOES(GLuint array) {
   GL_SERVICE_LOG("glBindVertexArrayOES"
                  << "(" << array << ")");
+  DCHECK(g_driver_gl.debug_fn.glBindVertexArrayOESFn != nullptr);
   g_driver_gl.debug_fn.glBindVertexArrayOESFn(array);
 }
 
 static void GL_BINDING_CALL Debug_glBlendBarrierKHR(void) {
   GL_SERVICE_LOG("glBlendBarrierKHR"
                  << "("
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glBlendBarrierKHRFn != nullptr);
   g_driver_gl.debug_fn.glBlendBarrierKHRFn();
 }
 
 static void GL_BINDING_CALL Debug_glBlendColor(GLclampf red,
                                                GLclampf green,
                                                GLclampf blue,
                                                GLclampf alpha) {
   GL_SERVICE_LOG("glBlendColor"
                  << "(" << red << ", " << green << ", " << blue << ", " << alpha
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glBlendColorFn != nullptr);
   g_driver_gl.debug_fn.glBlendColorFn(red, green, blue, alpha);
 }
 
 static void GL_BINDING_CALL Debug_glBlendEquation(GLenum mode) {
   GL_SERVICE_LOG("glBlendEquation"
                  << "(" << GLEnums::GetStringEnum(mode) << ")");
+  DCHECK(g_driver_gl.debug_fn.glBlendEquationFn != nullptr);
   g_driver_gl.debug_fn.glBlendEquationFn(mode);
 }
 
 static void GL_BINDING_CALL Debug_glBlendEquationSeparate(GLenum modeRGB,
                                                           GLenum modeAlpha) {
   GL_SERVICE_LOG("glBlendEquationSeparate"
                  << "(" << GLEnums::GetStringEnum(modeRGB) << ", "
                  << GLEnums::GetStringEnum(modeAlpha) << ")");
+  DCHECK(g_driver_gl.debug_fn.glBlendEquationSeparateFn != nullptr);
   g_driver_gl.debug_fn.glBlendEquationSeparateFn(modeRGB, modeAlpha);
 }
 
 static void GL_BINDING_CALL Debug_glBlendFunc(GLenum sfactor, GLenum dfactor) {
   GL_SERVICE_LOG("glBlendFunc"
                  << "(" << GLEnums::GetStringEnum(sfactor) << ", "
                  << GLEnums::GetStringEnum(dfactor) << ")");
+  DCHECK(g_driver_gl.debug_fn.glBlendFuncFn != nullptr);
   g_driver_gl.debug_fn.glBlendFuncFn(sfactor, dfactor);
 }
 
 static void GL_BINDING_CALL Debug_glBlendFuncSeparate(GLenum srcRGB,
                                                       GLenum dstRGB,
                                                       GLenum srcAlpha,
                                                       GLenum dstAlpha) {
   GL_SERVICE_LOG("glBlendFuncSeparate"
                  << "(" << GLEnums::GetStringEnum(srcRGB) << ", "
                  << GLEnums::GetStringEnum(dstRGB) << ", "
                  << GLEnums::GetStringEnum(srcAlpha) << ", "
                  << GLEnums::GetStringEnum(dstAlpha) << ")");
+  DCHECK(g_driver_gl.debug_fn.glBlendFuncSeparateFn != nullptr);
   g_driver_gl.debug_fn.glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha,
                                              dstAlpha);
 }
 
 static void GL_BINDING_CALL Debug_glBlitFramebuffer(GLint srcX0,
                                                     GLint srcY0,
                                                     GLint srcX1,
                                                     GLint srcY1,
                                                     GLint dstX0,
                                                     GLint dstY0,
                                                     GLint dstX1,
                                                     GLint dstY1,
                                                     GLbitfield mask,
                                                     GLenum filter) {
   GL_SERVICE_LOG("glBlitFramebuffer"
                  << "(" << srcX0 << ", " << srcY0 << ", " << srcX1 << ", "
                  << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1
                  << ", " << dstY1 << ", " << mask << ", "
                  << GLEnums::GetStringEnum(filter) << ")");
+  DCHECK(g_driver_gl.debug_fn.glBlitFramebufferFn != nullptr);
   g_driver_gl.debug_fn.glBlitFramebufferFn(srcX0, srcY0, srcX1, srcY1, dstX0,
                                            dstY0, dstX1, dstY1, mask, filter);
 }
 
 static void GL_BINDING_CALL Debug_glBlitFramebufferANGLE(GLint srcX0,
                                                          GLint srcY0,
                                                          GLint srcX1,
                                                          GLint srcY1,
                                                          GLint dstX0,
                                                          GLint dstY0,
                                                          GLint dstX1,
                                                          GLint dstY1,
                                                          GLbitfield mask,
                                                          GLenum filter) {
   GL_SERVICE_LOG("glBlitFramebufferANGLE"
                  << "(" << srcX0 << ", " << srcY0 << ", " << srcX1 << ", "
                  << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1
                  << ", " << dstY1 << ", " << mask << ", "
                  << GLEnums::GetStringEnum(filter) << ")");
+  DCHECK(g_driver_gl.debug_fn.glBlitFramebufferANGLEFn != nullptr);
   g_driver_gl.debug_fn.glBlitFramebufferANGLEFn(
       srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 static void GL_BINDING_CALL Debug_glBlitFramebufferEXT(GLint srcX0,
                                                        GLint srcY0,
                                                        GLint srcX1,
                                                        GLint srcY1,
                                                        GLint dstX0,
                                                        GLint dstY0,
                                                        GLint dstX1,
                                                        GLint dstY1,
                                                        GLbitfield mask,
                                                        GLenum filter) {
   GL_SERVICE_LOG("glBlitFramebufferEXT"
                  << "(" << srcX0 << ", " << srcY0 << ", " << srcX1 << ", "
                  << srcY1 << ", " << dstX0 << ", " << dstY0 << ", " << dstX1
                  << ", " << dstY1 << ", " << mask << ", "
                  << GLEnums::GetStringEnum(filter) << ")");
+  DCHECK(g_driver_gl.debug_fn.glBlitFramebufferEXTFn != nullptr);
   g_driver_gl.debug_fn.glBlitFramebufferEXTFn(
       srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 static void GL_BINDING_CALL Debug_glBufferData(GLenum target,
                                                GLsizeiptr size,
                                                const void* data,
                                                GLenum usage) {
   GL_SERVICE_LOG("glBufferData"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << size
                  << ", " << static_cast<const void*>(data) << ", "
                  << GLEnums::GetStringEnum(usage) << ")");
+  DCHECK(g_driver_gl.debug_fn.glBufferDataFn != nullptr);
   g_driver_gl.debug_fn.glBufferDataFn(target, size, data, usage);
 }
 
 static void GL_BINDING_CALL Debug_glBufferSubData(GLenum target,
                                                   GLintptr offset,
                                                   GLsizeiptr size,
                                                   const void* data) {
   GL_SERVICE_LOG("glBufferSubData"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << offset
                  << ", " << size << ", " << static_cast<const void*>(data)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glBufferSubDataFn != nullptr);
   g_driver_gl.debug_fn.glBufferSubDataFn(target, offset, size, data);
 }
 
 static GLenum GL_BINDING_CALL Debug_glCheckFramebufferStatusEXT(GLenum target) {
   GL_SERVICE_LOG("glCheckFramebufferStatusEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ")");
+  DCHECK(g_driver_gl.debug_fn.glCheckFramebufferStatusEXTFn != nullptr);
   GLenum result = g_driver_gl.debug_fn.glCheckFramebufferStatusEXTFn(target);
 
   GL_SERVICE_LOG("GL_RESULT: " << GLEnums::GetStringEnum(result));
 
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glClear(GLbitfield mask) {
   GL_SERVICE_LOG("glClear"
                  << "(" << mask << ")");
+  DCHECK(g_driver_gl.debug_fn.glClearFn != nullptr);
   g_driver_gl.debug_fn.glClearFn(mask);
 }
 
 static void GL_BINDING_CALL Debug_glClearBufferfi(GLenum buffer,
                                                   GLint drawbuffer,
                                                   const GLfloat depth,
                                                   GLint stencil) {
   GL_SERVICE_LOG("glClearBufferfi"
                  << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer
                  << ", " << depth << ", " << stencil << ")");
+  DCHECK(g_driver_gl.debug_fn.glClearBufferfiFn != nullptr);
   g_driver_gl.debug_fn.glClearBufferfiFn(buffer, drawbuffer, depth, stencil);
 }
 
 static void GL_BINDING_CALL Debug_glClearBufferfv(GLenum buffer,
                                                   GLint drawbuffer,
                                                   const GLfloat* value) {
   GL_SERVICE_LOG("glClearBufferfv"
                  << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer
                  << ", " << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_gl.debug_fn.glClearBufferfvFn != nullptr);
   g_driver_gl.debug_fn.glClearBufferfvFn(buffer, drawbuffer, value);
 }
 
 static void GL_BINDING_CALL Debug_glClearBufferiv(GLenum buffer,
                                                   GLint drawbuffer,
                                                   const GLint* value) {
   GL_SERVICE_LOG("glClearBufferiv"
                  << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer
                  << ", " << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_gl.debug_fn.glClearBufferivFn != nullptr);
   g_driver_gl.debug_fn.glClearBufferivFn(buffer, drawbuffer, value);
 }
 
 static void GL_BINDING_CALL Debug_glClearBufferuiv(GLenum buffer,
                                                    GLint drawbuffer,
                                                    const GLuint* value) {
   GL_SERVICE_LOG("glClearBufferuiv"
                  << "(" << GLEnums::GetStringEnum(buffer) << ", " << drawbuffer
                  << ", " << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_gl.debug_fn.glClearBufferuivFn != nullptr);
   g_driver_gl.debug_fn.glClearBufferuivFn(buffer, drawbuffer, value);
 }
 
 static void GL_BINDING_CALL Debug_glClearColor(GLclampf red,
                                                GLclampf green,
                                                GLclampf blue,
                                                GLclampf alpha) {
   GL_SERVICE_LOG("glClearColor"
                  << "(" << red << ", " << green << ", " << blue << ", " << alpha
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glClearColorFn != nullptr);
   g_driver_gl.debug_fn.glClearColorFn(red, green, blue, alpha);
 }
 
 static void GL_BINDING_CALL Debug_glClearDepth(GLclampd depth) {
   GL_SERVICE_LOG("glClearDepth"
                  << "(" << depth << ")");
+  DCHECK(g_driver_gl.debug_fn.glClearDepthFn != nullptr);
   g_driver_gl.debug_fn.glClearDepthFn(depth);
 }
 
 static void GL_BINDING_CALL Debug_glClearDepthf(GLclampf depth) {
   GL_SERVICE_LOG("glClearDepthf"
                  << "(" << depth << ")");
+  DCHECK(g_driver_gl.debug_fn.glClearDepthfFn != nullptr);
   g_driver_gl.debug_fn.glClearDepthfFn(depth);
 }
 
 static void GL_BINDING_CALL Debug_glClearStencil(GLint s) {
   GL_SERVICE_LOG("glClearStencil"
                  << "(" << s << ")");
+  DCHECK(g_driver_gl.debug_fn.glClearStencilFn != nullptr);
   g_driver_gl.debug_fn.glClearStencilFn(s);
 }
 
 static GLenum GL_BINDING_CALL Debug_glClientWaitSync(GLsync sync,
                                                      GLbitfield flags,
                                                      GLuint64 timeout) {
   GL_SERVICE_LOG("glClientWaitSync"
                  << "(" << sync << ", " << flags << ", " << timeout << ")");
+  DCHECK(g_driver_gl.debug_fn.glClientWaitSyncFn != nullptr);
   GLenum result = g_driver_gl.debug_fn.glClientWaitSyncFn(sync, flags, timeout);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glColorMask(GLboolean red,
                                               GLboolean green,
                                               GLboolean blue,
                                               GLboolean alpha) {
   GL_SERVICE_LOG("glColorMask"
                  << "(" << GLEnums::GetStringBool(red) << ", "
                  << GLEnums::GetStringBool(green) << ", "
                  << GLEnums::GetStringBool(blue) << ", "
                  << GLEnums::GetStringBool(alpha) << ")");
+  DCHECK(g_driver_gl.debug_fn.glColorMaskFn != nullptr);
   g_driver_gl.debug_fn.glColorMaskFn(red, green, blue, alpha);
 }
 
 static void GL_BINDING_CALL Debug_glCompileShader(GLuint shader) {
   GL_SERVICE_LOG("glCompileShader"
                  << "(" << shader << ")");
+  DCHECK(g_driver_gl.debug_fn.glCompileShaderFn != nullptr);
   g_driver_gl.debug_fn.glCompileShaderFn(shader);
 }
 
 static void GL_BINDING_CALL Debug_glCompressedTexImage2D(GLenum target,
                                                          GLint level,
                                                          GLenum internalformat,
                                                          GLsizei width,
                                                          GLsizei height,
                                                          GLint border,
                                                          GLsizei imageSize,
                                                          const void* data) {
   GL_SERVICE_LOG("glCompressedTexImage2D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << GLEnums::GetStringEnum(internalformat) << ", "
                  << width << ", " << height << ", " << border << ", "
                  << imageSize << ", " << static_cast<const void*>(data) << ")");
+  DCHECK(g_driver_gl.debug_fn.glCompressedTexImage2DFn != nullptr);
   g_driver_gl.debug_fn.glCompressedTexImage2DFn(
       target, level, internalformat, width, height, border, imageSize, data);
 }
 
 static void GL_BINDING_CALL Debug_glCompressedTexImage3D(GLenum target,
                                                          GLint level,
                                                          GLenum internalformat,
                                                          GLsizei width,
                                                          GLsizei height,
                                                          GLsizei depth,
                                                          GLint border,
                                                          GLsizei imageSize,
                                                          const void* data) {
   GL_SERVICE_LOG("glCompressedTexImage3D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << GLEnums::GetStringEnum(internalformat) << ", "
                  << width << ", " << height << ", " << depth << ", " << border
                  << ", " << imageSize << ", " << static_cast<const void*>(data)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glCompressedTexImage3DFn != nullptr);
   g_driver_gl.debug_fn.glCompressedTexImage3DFn(target, level, internalformat,
                                                 width, height, depth, border,
                                                 imageSize, data);
 }
 
 static void GL_BINDING_CALL Debug_glCompressedTexSubImage2D(GLenum target,
                                                             GLint level,
                                                             GLint xoffset,
                                                             GLint yoffset,
                                                             GLsizei width,
                                                             GLsizei height,
                                                             GLenum format,
                                                             GLsizei imageSize,
                                                             const void* data) {
   GL_SERVICE_LOG("glCompressedTexSubImage2D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << xoffset << ", " << yoffset << ", " << width << ", "
                  << height << ", " << GLEnums::GetStringEnum(format) << ", "
                  << imageSize << ", " << static_cast<const void*>(data) << ")");
+  DCHECK(g_driver_gl.debug_fn.glCompressedTexSubImage2DFn != nullptr);
   g_driver_gl.debug_fn.glCompressedTexSubImage2DFn(
       target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 static void GL_BINDING_CALL Debug_glCompressedTexSubImage3D(GLenum target,
                                                             GLint level,
                                                             GLint xoffset,
                                                             GLint yoffset,
                                                             GLint zoffset,
                                                             GLsizei width,
                                                             GLsizei height,
                                                             GLsizei depth,
                                                             GLenum format,
                                                             GLsizei imageSize,
                                                             const void* data) {
   GL_SERVICE_LOG("glCompressedTexSubImage3D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << xoffset << ", " << yoffset << ", " << zoffset
                  << ", " << width << ", " << height << ", " << depth << ", "
                  << GLEnums::GetStringEnum(format) << ", " << imageSize << ", "
                  << static_cast<const void*>(data) << ")");
+  DCHECK(g_driver_gl.debug_fn.glCompressedTexSubImage3DFn != nullptr);
   g_driver_gl.debug_fn.glCompressedTexSubImage3DFn(
       target, level, xoffset, yoffset, zoffset, width, height, depth, format,
       imageSize, data);
 }
 
 static void GL_BINDING_CALL Debug_glCopyBufferSubData(GLenum readTarget,
                                                       GLenum writeTarget,
                                                       GLintptr readOffset,
                                                       GLintptr writeOffset,
                                                       GLsizeiptr size) {
   GL_SERVICE_LOG("glCopyBufferSubData"
                  << "(" << GLEnums::GetStringEnum(readTarget) << ", "
                  << GLEnums::GetStringEnum(writeTarget) << ", " << readOffset
                  << ", " << writeOffset << ", " << size << ")");
+  DCHECK(g_driver_gl.debug_fn.glCopyBufferSubDataFn != nullptr);
   g_driver_gl.debug_fn.glCopyBufferSubDataFn(readTarget, writeTarget,
                                              readOffset, writeOffset, size);
 }
 
 static void GL_BINDING_CALL Debug_glCopyTexImage2D(GLenum target,
                                                    GLint level,
                                                    GLenum internalformat,
                                                    GLint x,
                                                    GLint y,
                                                    GLsizei width,
                                                    GLsizei height,
                                                    GLint border) {
   GL_SERVICE_LOG("glCopyTexImage2D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << GLEnums::GetStringEnum(internalformat) << ", " << x
                  << ", " << y << ", " << width << ", " << height << ", "
                  << border << ")");
+  DCHECK(g_driver_gl.debug_fn.glCopyTexImage2DFn != nullptr);
   g_driver_gl.debug_fn.glCopyTexImage2DFn(target, level, internalformat, x, y,
                                           width, height, border);
 }
 
 static void GL_BINDING_CALL Debug_glCopyTexSubImage2D(GLenum target,
                                                       GLint level,
                                                       GLint xoffset,
                                                       GLint yoffset,
                                                       GLint x,
                                                       GLint y,
                                                       GLsizei width,
                                                       GLsizei height) {
   GL_SERVICE_LOG("glCopyTexSubImage2D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << xoffset << ", " << yoffset << ", " << x << ", " << y
                  << ", " << width << ", " << height << ")");
+  DCHECK(g_driver_gl.debug_fn.glCopyTexSubImage2DFn != nullptr);
   g_driver_gl.debug_fn.glCopyTexSubImage2DFn(target, level, xoffset, yoffset, x,
                                              y, width, height);
 }
 
 static void GL_BINDING_CALL Debug_glCopyTexSubImage3D(GLenum target,
                                                       GLint level,
                                                       GLint xoffset,
                                                       GLint yoffset,
                                                       GLint zoffset,
                                                       GLint x,
                                                       GLint y,
                                                       GLsizei width,
                                                       GLsizei height) {
   GL_SERVICE_LOG("glCopyTexSubImage3D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << xoffset << ", " << yoffset << ", " << zoffset
                  << ", " << x << ", " << y << ", " << width << ", " << height
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glCopyTexSubImage3DFn != nullptr);
   g_driver_gl.debug_fn.glCopyTexSubImage3DFn(target, level, xoffset, yoffset,
                                              zoffset, x, y, width, height);
 }
 
 static void GL_BINDING_CALL Debug_glCoverageModulationNV(GLenum components) {
   GL_SERVICE_LOG("glCoverageModulationNV"
                  << "(" << GLEnums::GetStringEnum(components) << ")");
+  DCHECK(g_driver_gl.debug_fn.glCoverageModulationNVFn != nullptr);
   g_driver_gl.debug_fn.glCoverageModulationNVFn(components);
 }
 
 static void GL_BINDING_CALL
 Debug_glCoverFillPathInstancedNV(GLsizei numPaths,
                                  GLenum pathNameType,
                                  const void* paths,
                                  GLuint pathBase,
                                  GLenum coverMode,
                                  GLenum transformType,
                                  const GLfloat* transformValues) {
   GL_SERVICE_LOG("glCoverFillPathInstancedNV"
                  << "(" << numPaths << ", "
                  << GLEnums::GetStringEnum(pathNameType) << ", "
                  << static_cast<const void*>(paths) << ", " << pathBase << ", "
                  << GLEnums::GetStringEnum(coverMode) << ", "
                  << GLEnums::GetStringEnum(transformType) << ", "
                  << static_cast<const void*>(transformValues) << ")");
+  DCHECK(g_driver_gl.debug_fn.glCoverFillPathInstancedNVFn != nullptr);
   g_driver_gl.debug_fn.glCoverFillPathInstancedNVFn(
       numPaths, pathNameType, paths, pathBase, coverMode, transformType,
       transformValues);
 }
 
 static void GL_BINDING_CALL Debug_glCoverFillPathNV(GLuint path,
                                                     GLenum coverMode) {
   GL_SERVICE_LOG("glCoverFillPathNV"
                  << "(" << path << ", " << GLEnums::GetStringEnum(coverMode)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glCoverFillPathNVFn != nullptr);
   g_driver_gl.debug_fn.glCoverFillPathNVFn(path, coverMode);
 }
 
 static void GL_BINDING_CALL
 Debug_glCoverStrokePathInstancedNV(GLsizei numPaths,
                                    GLenum pathNameType,
                                    const void* paths,
                                    GLuint pathBase,
                                    GLenum coverMode,
                                    GLenum transformType,
                                    const GLfloat* transformValues) {
   GL_SERVICE_LOG("glCoverStrokePathInstancedNV"
                  << "(" << numPaths << ", "
                  << GLEnums::GetStringEnum(pathNameType) << ", "
                  << static_cast<const void*>(paths) << ", " << pathBase << ", "
                  << GLEnums::GetStringEnum(coverMode) << ", "
                  << GLEnums::GetStringEnum(transformType) << ", "
                  << static_cast<const void*>(transformValues) << ")");
+  DCHECK(g_driver_gl.debug_fn.glCoverStrokePathInstancedNVFn != nullptr);
   g_driver_gl.debug_fn.glCoverStrokePathInstancedNVFn(
       numPaths, pathNameType, paths, pathBase, coverMode, transformType,
       transformValues);
 }
 
 static void GL_BINDING_CALL Debug_glCoverStrokePathNV(GLuint name,
                                                       GLenum coverMode) {
   GL_SERVICE_LOG("glCoverStrokePathNV"
                  << "(" << name << ", " << GLEnums::GetStringEnum(coverMode)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glCoverStrokePathNVFn != nullptr);
   g_driver_gl.debug_fn.glCoverStrokePathNVFn(name, coverMode);
 }
 
 static GLuint GL_BINDING_CALL Debug_glCreateProgram(void) {
   GL_SERVICE_LOG("glCreateProgram"
                  << "("
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glCreateProgramFn != nullptr);
   GLuint result = g_driver_gl.debug_fn.glCreateProgramFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLuint GL_BINDING_CALL Debug_glCreateShader(GLenum type) {
   GL_SERVICE_LOG("glCreateShader"
                  << "(" << GLEnums::GetStringEnum(type) << ")");
+  DCHECK(g_driver_gl.debug_fn.glCreateShaderFn != nullptr);
   GLuint result = g_driver_gl.debug_fn.glCreateShaderFn(type);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glCullFace(GLenum mode) {
   GL_SERVICE_LOG("glCullFace"
                  << "(" << GLEnums::GetStringEnum(mode) << ")");
+  DCHECK(g_driver_gl.debug_fn.glCullFaceFn != nullptr);
   g_driver_gl.debug_fn.glCullFaceFn(mode);
 }
 
 static void GL_BINDING_CALL Debug_glDeleteBuffersARB(GLsizei n,
                                                      const GLuint* buffers) {
   GL_SERVICE_LOG("glDeleteBuffersARB"
                  << "(" << n << ", " << static_cast<const void*>(buffers)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteBuffersARBFn != nullptr);
   g_driver_gl.debug_fn.glDeleteBuffersARBFn(n, buffers);
 }
 
 static void GL_BINDING_CALL Debug_glDeleteFencesAPPLE(GLsizei n,
                                                       const GLuint* fences) {
   GL_SERVICE_LOG("glDeleteFencesAPPLE"
                  << "(" << n << ", " << static_cast<const void*>(fences)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteFencesAPPLEFn != nullptr);
   g_driver_gl.debug_fn.glDeleteFencesAPPLEFn(n, fences);
 }
 
 static void GL_BINDING_CALL Debug_glDeleteFencesNV(GLsizei n,
                                                    const GLuint* fences) {
   GL_SERVICE_LOG("glDeleteFencesNV"
                  << "(" << n << ", " << static_cast<const void*>(fences)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteFencesNVFn != nullptr);
   g_driver_gl.debug_fn.glDeleteFencesNVFn(n, fences);
 }
 
 static void GL_BINDING_CALL
 Debug_glDeleteFramebuffersEXT(GLsizei n, const GLuint* framebuffers) {
   GL_SERVICE_LOG("glDeleteFramebuffersEXT"
                  << "(" << n << ", " << static_cast<const void*>(framebuffers)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteFramebuffersEXTFn != nullptr);
   g_driver_gl.debug_fn.glDeleteFramebuffersEXTFn(n, framebuffers);
 }
 
 static void GL_BINDING_CALL Debug_glDeletePathsNV(GLuint path, GLsizei range) {
   GL_SERVICE_LOG("glDeletePathsNV"
                  << "(" << path << ", " << range << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeletePathsNVFn != nullptr);
   g_driver_gl.debug_fn.glDeletePathsNVFn(path, range);
 }
 
 static void GL_BINDING_CALL Debug_glDeleteProgram(GLuint program) {
   GL_SERVICE_LOG("glDeleteProgram"
                  << "(" << program << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteProgramFn != nullptr);
   g_driver_gl.debug_fn.glDeleteProgramFn(program);
 }
 
 static void GL_BINDING_CALL Debug_glDeleteQueries(GLsizei n,
                                                   const GLuint* ids) {
   GL_SERVICE_LOG("glDeleteQueries"
                  << "(" << n << ", " << static_cast<const void*>(ids) << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteQueriesFn != nullptr);
   g_driver_gl.debug_fn.glDeleteQueriesFn(n, ids);
 }
 
 static void GL_BINDING_CALL
 Debug_glDeleteRenderbuffersEXT(GLsizei n, const GLuint* renderbuffers) {
   GL_SERVICE_LOG("glDeleteRenderbuffersEXT"
                  << "(" << n << ", " << static_cast<const void*>(renderbuffers)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteRenderbuffersEXTFn != nullptr);
   g_driver_gl.debug_fn.glDeleteRenderbuffersEXTFn(n, renderbuffers);
 }
 
 static void GL_BINDING_CALL Debug_glDeleteSamplers(GLsizei n,
                                                    const GLuint* samplers) {
   GL_SERVICE_LOG("glDeleteSamplers"
                  << "(" << n << ", " << static_cast<const void*>(samplers)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteSamplersFn != nullptr);
   g_driver_gl.debug_fn.glDeleteSamplersFn(n, samplers);
 }
 
 static void GL_BINDING_CALL Debug_glDeleteShader(GLuint shader) {
   GL_SERVICE_LOG("glDeleteShader"
                  << "(" << shader << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteShaderFn != nullptr);
   g_driver_gl.debug_fn.glDeleteShaderFn(shader);
 }
 
 static void GL_BINDING_CALL Debug_glDeleteSync(GLsync sync) {
   GL_SERVICE_LOG("glDeleteSync"
                  << "(" << sync << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteSyncFn != nullptr);
   g_driver_gl.debug_fn.glDeleteSyncFn(sync);
 }
 
 static void GL_BINDING_CALL Debug_glDeleteTextures(GLsizei n,
                                                    const GLuint* textures) {
   GL_SERVICE_LOG("glDeleteTextures"
                  << "(" << n << ", " << static_cast<const void*>(textures)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteTexturesFn != nullptr);
   g_driver_gl.debug_fn.glDeleteTexturesFn(n, textures);
 }
 
 static void GL_BINDING_CALL
 Debug_glDeleteTransformFeedbacks(GLsizei n, const GLuint* ids) {
   GL_SERVICE_LOG("glDeleteTransformFeedbacks"
                  << "(" << n << ", " << static_cast<const void*>(ids) << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteTransformFeedbacksFn != nullptr);
   g_driver_gl.debug_fn.glDeleteTransformFeedbacksFn(n, ids);
 }
 
 static void GL_BINDING_CALL
 Debug_glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays) {
   GL_SERVICE_LOG("glDeleteVertexArraysOES"
                  << "(" << n << ", " << static_cast<const void*>(arrays)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glDeleteVertexArraysOESFn != nullptr);
   g_driver_gl.debug_fn.glDeleteVertexArraysOESFn(n, arrays);
 }
 
 static void GL_BINDING_CALL Debug_glDepthFunc(GLenum func) {
   GL_SERVICE_LOG("glDepthFunc"
                  << "(" << GLEnums::GetStringEnum(func) << ")");
+  DCHECK(g_driver_gl.debug_fn.glDepthFuncFn != nullptr);
   g_driver_gl.debug_fn.glDepthFuncFn(func);
 }
 
 static void GL_BINDING_CALL Debug_glDepthMask(GLboolean flag) {
   GL_SERVICE_LOG("glDepthMask"
                  << "(" << GLEnums::GetStringBool(flag) << ")");
+  DCHECK(g_driver_gl.debug_fn.glDepthMaskFn != nullptr);
   g_driver_gl.debug_fn.glDepthMaskFn(flag);
 }
 
 static void GL_BINDING_CALL Debug_glDepthRange(GLclampd zNear, GLclampd zFar) {
   GL_SERVICE_LOG("glDepthRange"
                  << "(" << zNear << ", " << zFar << ")");
+  DCHECK(g_driver_gl.debug_fn.glDepthRangeFn != nullptr);
   g_driver_gl.debug_fn.glDepthRangeFn(zNear, zFar);
 }
 
 static void GL_BINDING_CALL Debug_glDepthRangef(GLclampf zNear, GLclampf zFar) {
   GL_SERVICE_LOG("glDepthRangef"
                  << "(" << zNear << ", " << zFar << ")");
+  DCHECK(g_driver_gl.debug_fn.glDepthRangefFn != nullptr);
   g_driver_gl.debug_fn.glDepthRangefFn(zNear, zFar);
 }
 
 static void GL_BINDING_CALL Debug_glDetachShader(GLuint program,
                                                  GLuint shader) {
   GL_SERVICE_LOG("glDetachShader"
                  << "(" << program << ", " << shader << ")");
+  DCHECK(g_driver_gl.debug_fn.glDetachShaderFn != nullptr);
   g_driver_gl.debug_fn.glDetachShaderFn(program, shader);
 }
 
 static void GL_BINDING_CALL Debug_glDisable(GLenum cap) {
   GL_SERVICE_LOG("glDisable"
                  << "(" << GLEnums::GetStringEnum(cap) << ")");
+  DCHECK(g_driver_gl.debug_fn.glDisableFn != nullptr);
   g_driver_gl.debug_fn.glDisableFn(cap);
 }
 
 static void GL_BINDING_CALL Debug_glDisableVertexAttribArray(GLuint index) {
   GL_SERVICE_LOG("glDisableVertexAttribArray"
                  << "(" << index << ")");
+  DCHECK(g_driver_gl.debug_fn.glDisableVertexAttribArrayFn != nullptr);
   g_driver_gl.debug_fn.glDisableVertexAttribArrayFn(index);
 }
 
 static void GL_BINDING_CALL
 Debug_glDiscardFramebufferEXT(GLenum target,
                               GLsizei numAttachments,
                               const GLenum* attachments) {
   GL_SERVICE_LOG("glDiscardFramebufferEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << numAttachments << ", "
                  << static_cast<const void*>(attachments) << ")");
+  DCHECK(g_driver_gl.debug_fn.glDiscardFramebufferEXTFn != nullptr);
   g_driver_gl.debug_fn.glDiscardFramebufferEXTFn(target, numAttachments,
                                                  attachments);
 }
 
 static void GL_BINDING_CALL Debug_glDrawArrays(GLenum mode,
                                                GLint first,
                                                GLsizei count) {
   GL_SERVICE_LOG("glDrawArrays"
                  << "(" << GLEnums::GetStringEnum(mode) << ", " << first << ", "
                  << count << ")");
+  DCHECK(g_driver_gl.debug_fn.glDrawArraysFn != nullptr);
   g_driver_gl.debug_fn.glDrawArraysFn(mode, first, count);
 }
 
 static void GL_BINDING_CALL
 Debug_glDrawArraysInstancedANGLE(GLenum mode,
                                  GLint first,
                                  GLsizei count,
                                  GLsizei primcount) {
   GL_SERVICE_LOG("glDrawArraysInstancedANGLE"
                  << "(" << GLEnums::GetStringEnum(mode) << ", " << first << ", "
                  << count << ", " << primcount << ")");
+  DCHECK(g_driver_gl.debug_fn.glDrawArraysInstancedANGLEFn != nullptr);
   g_driver_gl.debug_fn.glDrawArraysInstancedANGLEFn(mode, first, count,
                                                     primcount);
 }
 
 static void GL_BINDING_CALL Debug_glDrawBuffer(GLenum mode) {
   GL_SERVICE_LOG("glDrawBuffer"
                  << "(" << GLEnums::GetStringEnum(mode) << ")");
+  DCHECK(g_driver_gl.debug_fn.glDrawBufferFn != nullptr);
   g_driver_gl.debug_fn.glDrawBufferFn(mode);
 }
 
 static void GL_BINDING_CALL Debug_glDrawBuffersARB(GLsizei n,
                                                    const GLenum* bufs) {
   GL_SERVICE_LOG("glDrawBuffersARB"
                  << "(" << n << ", " << static_cast<const void*>(bufs) << ")");
+  DCHECK(g_driver_gl.debug_fn.glDrawBuffersARBFn != nullptr);
   g_driver_gl.debug_fn.glDrawBuffersARBFn(n, bufs);
 }
 
 static void GL_BINDING_CALL Debug_glDrawElements(GLenum mode,
                                                  GLsizei count,
                                                  GLenum type,
                                                  const void* indices) {
   GL_SERVICE_LOG("glDrawElements"
                  << "(" << GLEnums::GetStringEnum(mode) << ", " << count << ", "
                  << GLEnums::GetStringEnum(type) << ", "
                  << static_cast<const void*>(indices) << ")");
+  DCHECK(g_driver_gl.debug_fn.glDrawElementsFn != nullptr);
   g_driver_gl.debug_fn.glDrawElementsFn(mode, count, type, indices);
 }
 
 static void GL_BINDING_CALL
 Debug_glDrawElementsInstancedANGLE(GLenum mode,
                                    GLsizei count,
                                    GLenum type,
                                    const void* indices,
                                    GLsizei primcount) {
   GL_SERVICE_LOG("glDrawElementsInstancedANGLE"
                  << "(" << GLEnums::GetStringEnum(mode) << ", " << count << ", "
                  << GLEnums::GetStringEnum(type) << ", "
                  << static_cast<const void*>(indices) << ", " << primcount
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glDrawElementsInstancedANGLEFn != nullptr);
   g_driver_gl.debug_fn.glDrawElementsInstancedANGLEFn(mode, count, type,
                                                       indices, primcount);
 }
 
 static void GL_BINDING_CALL Debug_glDrawRangeElements(GLenum mode,
                                                       GLuint start,
                                                       GLuint end,
                                                       GLsizei count,
                                                       GLenum type,
                                                       const void* indices) {
   GL_SERVICE_LOG("glDrawRangeElements"
                  << "(" << GLEnums::GetStringEnum(mode) << ", " << start << ", "
                  << end << ", " << count << ", " << GLEnums::GetStringEnum(type)
                  << ", " << static_cast<const void*>(indices) << ")");
+  DCHECK(g_driver_gl.debug_fn.glDrawRangeElementsFn != nullptr);
   g_driver_gl.debug_fn.glDrawRangeElementsFn(mode, start, end, count, type,
                                              indices);
 }
 
 static void GL_BINDING_CALL
 Debug_glEGLImageTargetRenderbufferStorageOES(GLenum target,
                                              GLeglImageOES image) {
   GL_SERVICE_LOG("glEGLImageTargetRenderbufferStorageOES"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << image
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glEGLImageTargetRenderbufferStorageOESFn !=
+         nullptr);
   g_driver_gl.debug_fn.glEGLImageTargetRenderbufferStorageOESFn(target, image);
 }
 
 static void GL_BINDING_CALL
 Debug_glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) {
   GL_SERVICE_LOG("glEGLImageTargetTexture2DOES"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << image
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glEGLImageTargetTexture2DOESFn != nullptr);
   g_driver_gl.debug_fn.glEGLImageTargetTexture2DOESFn(target, image);
 }
 
 static void GL_BINDING_CALL Debug_glEnable(GLenum cap) {
   GL_SERVICE_LOG("glEnable"
                  << "(" << GLEnums::GetStringEnum(cap) << ")");
+  DCHECK(g_driver_gl.debug_fn.glEnableFn != nullptr);
   g_driver_gl.debug_fn.glEnableFn(cap);
 }
 
 static void GL_BINDING_CALL Debug_glEnableVertexAttribArray(GLuint index) {
   GL_SERVICE_LOG("glEnableVertexAttribArray"
                  << "(" << index << ")");
+  DCHECK(g_driver_gl.debug_fn.glEnableVertexAttribArrayFn != nullptr);
   g_driver_gl.debug_fn.glEnableVertexAttribArrayFn(index);
 }
 
 static void GL_BINDING_CALL Debug_glEndQuery(GLenum target) {
   GL_SERVICE_LOG("glEndQuery"
                  << "(" << GLEnums::GetStringEnum(target) << ")");
+  DCHECK(g_driver_gl.debug_fn.glEndQueryFn != nullptr);
   g_driver_gl.debug_fn.glEndQueryFn(target);
 }
 
 static void GL_BINDING_CALL Debug_glEndTransformFeedback(void) {
   GL_SERVICE_LOG("glEndTransformFeedback"
                  << "("
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glEndTransformFeedbackFn != nullptr);
   g_driver_gl.debug_fn.glEndTransformFeedbackFn();
 }
 
 static GLsync GL_BINDING_CALL Debug_glFenceSync(GLenum condition,
                                                 GLbitfield flags) {
   GL_SERVICE_LOG("glFenceSync"
                  << "(" << GLEnums::GetStringEnum(condition) << ", " << flags
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glFenceSyncFn != nullptr);
   GLsync result = g_driver_gl.debug_fn.glFenceSyncFn(condition, flags);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glFinish(void) {
   GL_SERVICE_LOG("glFinish"
                  << "("
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glFinishFn != nullptr);
   g_driver_gl.debug_fn.glFinishFn();
 }
 
 static void GL_BINDING_CALL Debug_glFinishFenceAPPLE(GLuint fence) {
   GL_SERVICE_LOG("glFinishFenceAPPLE"
                  << "(" << fence << ")");
+  DCHECK(g_driver_gl.debug_fn.glFinishFenceAPPLEFn != nullptr);
   g_driver_gl.debug_fn.glFinishFenceAPPLEFn(fence);
 }
 
 static void GL_BINDING_CALL Debug_glFinishFenceNV(GLuint fence) {
   GL_SERVICE_LOG("glFinishFenceNV"
                  << "(" << fence << ")");
+  DCHECK(g_driver_gl.debug_fn.glFinishFenceNVFn != nullptr);
   g_driver_gl.debug_fn.glFinishFenceNVFn(fence);
 }
 
 static void GL_BINDING_CALL Debug_glFlush(void) {
   GL_SERVICE_LOG("glFlush"
                  << "("
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glFlushFn != nullptr);
   g_driver_gl.debug_fn.glFlushFn();
 }
 
 static void GL_BINDING_CALL Debug_glFlushMappedBufferRange(GLenum target,
                                                            GLintptr offset,
                                                            GLsizeiptr length) {
   GL_SERVICE_LOG("glFlushMappedBufferRange"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << offset
                  << ", " << length << ")");
+  DCHECK(g_driver_gl.debug_fn.glFlushMappedBufferRangeFn != nullptr);
   g_driver_gl.debug_fn.glFlushMappedBufferRangeFn(target, offset, length);
 }
 
 static void GL_BINDING_CALL
 Debug_glFramebufferRenderbufferEXT(GLenum target,
                                    GLenum attachment,
                                    GLenum renderbuffertarget,
                                    GLuint renderbuffer) {
   GL_SERVICE_LOG("glFramebufferRenderbufferEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(attachment) << ", "
                  << GLEnums::GetStringEnum(renderbuffertarget) << ", "
                  << renderbuffer << ")");
+  DCHECK(g_driver_gl.debug_fn.glFramebufferRenderbufferEXTFn != nullptr);
   g_driver_gl.debug_fn.glFramebufferRenderbufferEXTFn(
       target, attachment, renderbuffertarget, renderbuffer);
 }
 
 static void GL_BINDING_CALL Debug_glFramebufferTexture2DEXT(GLenum target,
                                                             GLenum attachment,
                                                             GLenum textarget,
                                                             GLuint texture,
                                                             GLint level) {
   GL_SERVICE_LOG("glFramebufferTexture2DEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(attachment) << ", "
                  << GLEnums::GetStringEnum(textarget) << ", " << texture << ", "
                  << level << ")");
+  DCHECK(g_driver_gl.debug_fn.glFramebufferTexture2DEXTFn != nullptr);
   g_driver_gl.debug_fn.glFramebufferTexture2DEXTFn(target, attachment,
                                                    textarget, texture, level);
 }
 
 static void GL_BINDING_CALL
 Debug_glFramebufferTexture2DMultisampleEXT(GLenum target,
                                            GLenum attachment,
                                            GLenum textarget,
                                            GLuint texture,
                                            GLint level,
                                            GLsizei samples) {
   GL_SERVICE_LOG("glFramebufferTexture2DMultisampleEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(attachment) << ", "
                  << GLEnums::GetStringEnum(textarget) << ", " << texture << ", "
                  << level << ", " << samples << ")");
+  DCHECK(g_driver_gl.debug_fn.glFramebufferTexture2DMultisampleEXTFn !=
+         nullptr);
   g_driver_gl.debug_fn.glFramebufferTexture2DMultisampleEXTFn(
       target, attachment, textarget, texture, level, samples);
 }
 
 static void GL_BINDING_CALL
 Debug_glFramebufferTexture2DMultisampleIMG(GLenum target,
                                            GLenum attachment,
                                            GLenum textarget,
                                            GLuint texture,
                                            GLint level,
                                            GLsizei samples) {
   GL_SERVICE_LOG("glFramebufferTexture2DMultisampleIMG"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(attachment) << ", "
                  << GLEnums::GetStringEnum(textarget) << ", " << texture << ", "
                  << level << ", " << samples << ")");
+  DCHECK(g_driver_gl.debug_fn.glFramebufferTexture2DMultisampleIMGFn !=
+         nullptr);
   g_driver_gl.debug_fn.glFramebufferTexture2DMultisampleIMGFn(
       target, attachment, textarget, texture, level, samples);
 }
 
 static void GL_BINDING_CALL Debug_glFramebufferTextureLayer(GLenum target,
                                                             GLenum attachment,
                                                             GLuint texture,
                                                             GLint level,
                                                             GLint layer) {
   GL_SERVICE_LOG("glFramebufferTextureLayer"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(attachment) << ", " << texture
                  << ", " << level << ", " << layer << ")");
+  DCHECK(g_driver_gl.debug_fn.glFramebufferTextureLayerFn != nullptr);
   g_driver_gl.debug_fn.glFramebufferTextureLayerFn(target, attachment, texture,
                                                    level, layer);
 }
 
 static void GL_BINDING_CALL Debug_glFrontFace(GLenum mode) {
   GL_SERVICE_LOG("glFrontFace"
                  << "(" << GLEnums::GetStringEnum(mode) << ")");
+  DCHECK(g_driver_gl.debug_fn.glFrontFaceFn != nullptr);
   g_driver_gl.debug_fn.glFrontFaceFn(mode);
 }
 
 static void GL_BINDING_CALL Debug_glGenBuffersARB(GLsizei n, GLuint* buffers) {
   GL_SERVICE_LOG("glGenBuffersARB"
                  << "(" << n << ", " << static_cast<const void*>(buffers)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glGenBuffersARBFn != nullptr);
   g_driver_gl.debug_fn.glGenBuffersARBFn(n, buffers);
 }
 
 static void GL_BINDING_CALL Debug_glGenerateMipmapEXT(GLenum target) {
   GL_SERVICE_LOG("glGenerateMipmapEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGenerateMipmapEXTFn != nullptr);
   g_driver_gl.debug_fn.glGenerateMipmapEXTFn(target);
 }
 
 static void GL_BINDING_CALL Debug_glGenFencesAPPLE(GLsizei n, GLuint* fences) {
   GL_SERVICE_LOG("glGenFencesAPPLE"
                  << "(" << n << ", " << static_cast<const void*>(fences)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glGenFencesAPPLEFn != nullptr);
   g_driver_gl.debug_fn.glGenFencesAPPLEFn(n, fences);
 }
 
 static void GL_BINDING_CALL Debug_glGenFencesNV(GLsizei n, GLuint* fences) {
   GL_SERVICE_LOG("glGenFencesNV"
                  << "(" << n << ", " << static_cast<const void*>(fences)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glGenFencesNVFn != nullptr);
   g_driver_gl.debug_fn.glGenFencesNVFn(n, fences);
 }
 
 static void GL_BINDING_CALL Debug_glGenFramebuffersEXT(GLsizei n,
                                                        GLuint* framebuffers) {
   GL_SERVICE_LOG("glGenFramebuffersEXT"
                  << "(" << n << ", " << static_cast<const void*>(framebuffers)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glGenFramebuffersEXTFn != nullptr);
   g_driver_gl.debug_fn.glGenFramebuffersEXTFn(n, framebuffers);
 }
 
 static GLuint GL_BINDING_CALL Debug_glGenPathsNV(GLsizei range) {
   GL_SERVICE_LOG("glGenPathsNV"
                  << "(" << range << ")");
+  DCHECK(g_driver_gl.debug_fn.glGenPathsNVFn != nullptr);
   GLuint result = g_driver_gl.debug_fn.glGenPathsNVFn(range);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glGenQueries(GLsizei n, GLuint* ids) {
   GL_SERVICE_LOG("glGenQueries"
                  << "(" << n << ", " << static_cast<const void*>(ids) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGenQueriesFn != nullptr);
   g_driver_gl.debug_fn.glGenQueriesFn(n, ids);
 }
 
 static void GL_BINDING_CALL Debug_glGenRenderbuffersEXT(GLsizei n,
                                                         GLuint* renderbuffers) {
   GL_SERVICE_LOG("glGenRenderbuffersEXT"
                  << "(" << n << ", " << static_cast<const void*>(renderbuffers)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glGenRenderbuffersEXTFn != nullptr);
   g_driver_gl.debug_fn.glGenRenderbuffersEXTFn(n, renderbuffers);
 }
 
 static void GL_BINDING_CALL Debug_glGenSamplers(GLsizei n, GLuint* samplers) {
   GL_SERVICE_LOG("glGenSamplers"
                  << "(" << n << ", " << static_cast<const void*>(samplers)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glGenSamplersFn != nullptr);
   g_driver_gl.debug_fn.glGenSamplersFn(n, samplers);
 }
 
 static void GL_BINDING_CALL Debug_glGenTextures(GLsizei n, GLuint* textures) {
   GL_SERVICE_LOG("glGenTextures"
                  << "(" << n << ", " << static_cast<const void*>(textures)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glGenTexturesFn != nullptr);
   g_driver_gl.debug_fn.glGenTexturesFn(n, textures);
 }
 
 static void GL_BINDING_CALL Debug_glGenTransformFeedbacks(GLsizei n,
                                                           GLuint* ids) {
   GL_SERVICE_LOG("glGenTransformFeedbacks"
                  << "(" << n << ", " << static_cast<const void*>(ids) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGenTransformFeedbacksFn != nullptr);
   g_driver_gl.debug_fn.glGenTransformFeedbacksFn(n, ids);
 }
 
 static void GL_BINDING_CALL Debug_glGenVertexArraysOES(GLsizei n,
                                                        GLuint* arrays) {
   GL_SERVICE_LOG("glGenVertexArraysOES"
                  << "(" << n << ", " << static_cast<const void*>(arrays)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glGenVertexArraysOESFn != nullptr);
   g_driver_gl.debug_fn.glGenVertexArraysOESFn(n, arrays);
 }
 
 static void GL_BINDING_CALL Debug_glGetActiveAttrib(GLuint program,
                                                     GLuint index,
                                                     GLsizei bufsize,
                                                     GLsizei* length,
                                                     GLint* size,
                                                     GLenum* type,
                                                     char* name) {
   GL_SERVICE_LOG("glGetActiveAttrib"
                  << "(" << program << ", " << index << ", " << bufsize << ", "
                  << static_cast<const void*>(length) << ", "
                  << static_cast<const void*>(size) << ", "
                  << static_cast<const void*>(type) << ", "
                  << static_cast<const void*>(name) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetActiveAttribFn != nullptr);
   g_driver_gl.debug_fn.glGetActiveAttribFn(program, index, bufsize, length,
                                            size, type, name);
 }
 
 static void GL_BINDING_CALL Debug_glGetActiveUniform(GLuint program,
                                                      GLuint index,
                                                      GLsizei bufsize,
                                                      GLsizei* length,
                                                      GLint* size,
                                                      GLenum* type,
                                                      char* name) {
   GL_SERVICE_LOG("glGetActiveUniform"
                  << "(" << program << ", " << index << ", " << bufsize << ", "
                  << static_cast<const void*>(length) << ", "
                  << static_cast<const void*>(size) << ", "
                  << static_cast<const void*>(type) << ", "
                  << static_cast<const void*>(name) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetActiveUniformFn != nullptr);
   g_driver_gl.debug_fn.glGetActiveUniformFn(program, index, bufsize, length,
                                             size, type, name);
 }
 
 static void GL_BINDING_CALL
 Debug_glGetActiveUniformBlockiv(GLuint program,
                                 GLuint uniformBlockIndex,
                                 GLenum pname,
                                 GLint* params) {
   GL_SERVICE_LOG("glGetActiveUniformBlockiv"
                  << "(" << program << ", " << uniformBlockIndex << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetActiveUniformBlockivFn != nullptr);
   g_driver_gl.debug_fn.glGetActiveUniformBlockivFn(program, uniformBlockIndex,
                                                    pname, params);
 }
 
 static void GL_BINDING_CALL
 Debug_glGetActiveUniformBlockName(GLuint program,
                                   GLuint uniformBlockIndex,
                                   GLsizei bufSize,
                                   GLsizei* length,
                                   char* uniformBlockName) {
   GL_SERVICE_LOG("glGetActiveUniformBlockName"
                  << "(" << program << ", " << uniformBlockIndex << ", "
                  << bufSize << ", " << static_cast<const void*>(length) << ", "
                  << static_cast<const void*>(uniformBlockName) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetActiveUniformBlockNameFn != nullptr);
   g_driver_gl.debug_fn.glGetActiveUniformBlockNameFn(
       program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 static void GL_BINDING_CALL
 Debug_glGetActiveUniformsiv(GLuint program,
                             GLsizei uniformCount,
                             const GLuint* uniformIndices,
                             GLenum pname,
                             GLint* params) {
   GL_SERVICE_LOG("glGetActiveUniformsiv"
                  << "(" << program << ", " << uniformCount << ", "
                  << static_cast<const void*>(uniformIndices) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetActiveUniformsivFn != nullptr);
   g_driver_gl.debug_fn.glGetActiveUniformsivFn(program, uniformCount,
                                                uniformIndices, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetAttachedShaders(GLuint program,
                                                        GLsizei maxcount,
                                                        GLsizei* count,
                                                        GLuint* shaders) {
   GL_SERVICE_LOG("glGetAttachedShaders"
                  << "(" << program << ", " << maxcount << ", "
                  << static_cast<const void*>(count) << ", "
                  << static_cast<const void*>(shaders) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetAttachedShadersFn != nullptr);
   g_driver_gl.debug_fn.glGetAttachedShadersFn(program, maxcount, count,
                                               shaders);
 }
 
 static GLint GL_BINDING_CALL Debug_glGetAttribLocation(GLuint program,
                                                        const char* name) {
   GL_SERVICE_LOG("glGetAttribLocation"
                  << "(" << program << ", " << name << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetAttribLocationFn != nullptr);
   GLint result = g_driver_gl.debug_fn.glGetAttribLocationFn(program, name);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glGetBooleanv(GLenum pname,
                                                 GLboolean* params) {
   GL_SERVICE_LOG("glGetBooleanv"
                  << "(" << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetBooleanvFn != nullptr);
   g_driver_gl.debug_fn.glGetBooleanvFn(pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetBufferParameteriv(GLenum target,
                                                          GLenum pname,
                                                          GLint* params) {
   GL_SERVICE_LOG("glGetBufferParameteriv"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetBufferParameterivFn != nullptr);
   g_driver_gl.debug_fn.glGetBufferParameterivFn(target, pname, params);
 }
 
 static GLenum GL_BINDING_CALL Debug_glGetError(void) {
   GL_SERVICE_LOG("glGetError"
                  << "("
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetErrorFn != nullptr);
   GLenum result = g_driver_gl.debug_fn.glGetErrorFn();
 
   GL_SERVICE_LOG("GL_RESULT: " << GLEnums::GetStringError(result));
 
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glGetFenceivNV(GLuint fence,
                                                  GLenum pname,
                                                  GLint* params) {
   GL_SERVICE_LOG("glGetFenceivNV"
                  << "(" << fence << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetFenceivNVFn != nullptr);
   g_driver_gl.debug_fn.glGetFenceivNVFn(fence, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetFloatv(GLenum pname, GLfloat* params) {
   GL_SERVICE_LOG("glGetFloatv"
                  << "(" << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetFloatvFn != nullptr);
   g_driver_gl.debug_fn.glGetFloatvFn(pname, params);
 }
 
 static GLint GL_BINDING_CALL Debug_glGetFragDataIndex(GLuint program,
                                                       const char* name) {
   GL_SERVICE_LOG("glGetFragDataIndex"
                  << "(" << program << ", " << name << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetFragDataIndexFn != nullptr);
   GLint result = g_driver_gl.debug_fn.glGetFragDataIndexFn(program, name);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLint GL_BINDING_CALL Debug_glGetFragDataLocation(GLuint program,
                                                          const char* name) {
   GL_SERVICE_LOG("glGetFragDataLocation"
                  << "(" << program << ", " << name << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetFragDataLocationFn != nullptr);
   GLint result = g_driver_gl.debug_fn.glGetFragDataLocationFn(program, name);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL
 Debug_glGetFramebufferAttachmentParameterivEXT(GLenum target,
                                                GLenum attachment,
                                                GLenum pname,
                                                GLint* params) {
   GL_SERVICE_LOG("glGetFramebufferAttachmentParameterivEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(attachment) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetFramebufferAttachmentParameterivEXTFn !=
+         nullptr);
   g_driver_gl.debug_fn.glGetFramebufferAttachmentParameterivEXTFn(
       target, attachment, pname, params);
 }
 
 static GLenum GL_BINDING_CALL Debug_glGetGraphicsResetStatusARB(void) {
   GL_SERVICE_LOG("glGetGraphicsResetStatusARB"
                  << "("
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetGraphicsResetStatusARBFn != nullptr);
   GLenum result = g_driver_gl.debug_fn.glGetGraphicsResetStatusARBFn();
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glGetInteger64i_v(GLenum target,
                                                     GLuint index,
                                                     GLint64* data) {
   GL_SERVICE_LOG("glGetInteger64i_v"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << index
                  << ", " << static_cast<const void*>(data) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetInteger64i_vFn != nullptr);
   g_driver_gl.debug_fn.glGetInteger64i_vFn(target, index, data);
 }
 
 static void GL_BINDING_CALL Debug_glGetInteger64v(GLenum pname,
                                                   GLint64* params) {
   GL_SERVICE_LOG("glGetInteger64v"
                  << "(" << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetInteger64vFn != nullptr);
   g_driver_gl.debug_fn.glGetInteger64vFn(pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetIntegeri_v(GLenum target,
                                                   GLuint index,
                                                   GLint* data) {
   GL_SERVICE_LOG("glGetIntegeri_v"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << index
                  << ", " << static_cast<const void*>(data) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetIntegeri_vFn != nullptr);
   g_driver_gl.debug_fn.glGetIntegeri_vFn(target, index, data);
 }
 
 static void GL_BINDING_CALL Debug_glGetIntegerv(GLenum pname, GLint* params) {
   GL_SERVICE_LOG("glGetIntegerv"
                  << "(" << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetIntegervFn != nullptr);
   g_driver_gl.debug_fn.glGetIntegervFn(pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetInternalformativ(GLenum target,
                                                         GLenum internalformat,
                                                         GLenum pname,
                                                         GLsizei bufSize,
                                                         GLint* params) {
   GL_SERVICE_LOG("glGetInternalformativ"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(internalformat) << ", "
                  << GLEnums::GetStringEnum(pname) << ", " << bufSize << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetInternalformativFn != nullptr);
   g_driver_gl.debug_fn.glGetInternalformativFn(target, internalformat, pname,
                                                bufSize, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetProgramBinary(GLuint program,
                                                      GLsizei bufSize,
                                                      GLsizei* length,
                                                      GLenum* binaryFormat,
                                                      GLvoid* binary) {
   GL_SERVICE_LOG("glGetProgramBinary"
                  << "(" << program << ", " << bufSize << ", "
                  << static_cast<const void*>(length) << ", "
                  << static_cast<const void*>(binaryFormat) << ", "
                  << static_cast<const void*>(binary) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetProgramBinaryFn != nullptr);
   g_driver_gl.debug_fn.glGetProgramBinaryFn(program, bufSize, length,
                                             binaryFormat, binary);
 }
 
 static void GL_BINDING_CALL Debug_glGetProgramInfoLog(GLuint program,
                                                       GLsizei bufsize,
                                                       GLsizei* length,
                                                       char* infolog) {
   GL_SERVICE_LOG("glGetProgramInfoLog"
                  << "(" << program << ", " << bufsize << ", "
                  << static_cast<const void*>(length) << ", "
                  << static_cast<const void*>(infolog) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetProgramInfoLogFn != nullptr);
   g_driver_gl.debug_fn.glGetProgramInfoLogFn(program, bufsize, length, infolog);
 }
 
 static void GL_BINDING_CALL
 Debug_glGetProgramInterfaceiv(GLuint program,
                               GLenum programInterface,
                               GLenum pname,
                               GLint* params) {
   GL_SERVICE_LOG("glGetProgramInterfaceiv"
                  << "(" << program << ", "
                  << GLEnums::GetStringEnum(programInterface) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetProgramInterfaceivFn != nullptr);
   g_driver_gl.debug_fn.glGetProgramInterfaceivFn(program, programInterface,
                                                  pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetProgramiv(GLuint program,
                                                  GLenum pname,
                                                  GLint* params) {
   GL_SERVICE_LOG("glGetProgramiv"
                  << "(" << program << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetProgramivFn != nullptr);
   g_driver_gl.debug_fn.glGetProgramivFn(program, pname, params);
 }
 
 static void GL_BINDING_CALL
 Debug_glGetProgramResourceiv(GLuint program,
                              GLenum programInterface,
                              GLuint index,
                              GLsizei propCount,
                              const GLenum* props,
                              GLsizei bufSize,
                              GLsizei* length,
                              GLint* params) {
   GL_SERVICE_LOG("glGetProgramResourceiv"
                  << "(" << program << ", "
                  << GLEnums::GetStringEnum(programInterface) << ", " << index
                  << ", " << propCount << ", " << static_cast<const void*>(props)
                  << ", " << bufSize << ", " << static_cast<const void*>(length)
                  << ", " << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetProgramResourceivFn != nullptr);
   g_driver_gl.debug_fn.glGetProgramResourceivFn(program, programInterface,
                                                 index, propCount, props,
                                                 bufSize, length, params);
 }
 
 static GLint GL_BINDING_CALL
 Debug_glGetProgramResourceLocation(GLuint program,
                                    GLenum programInterface,
                                    const char* name) {
   GL_SERVICE_LOG("glGetProgramResourceLocation"
                  << "(" << program << ", "
                  << GLEnums::GetStringEnum(programInterface) << ", " << name
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetProgramResourceLocationFn != nullptr);
   GLint result = g_driver_gl.debug_fn.glGetProgramResourceLocationFn(
       program, programInterface, name);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL
 Debug_glGetProgramResourceName(GLuint program,
                                GLenum programInterface,
                                GLuint index,
                                GLsizei bufSize,
                                GLsizei* length,
                                GLchar* name) {
   GL_SERVICE_LOG("glGetProgramResourceName"
                  << "(" << program << ", "
                  << GLEnums::GetStringEnum(programInterface) << ", " << index
                  << ", " << bufSize << ", " << static_cast<const void*>(length)
                  << ", " << static_cast<const void*>(name) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetProgramResourceNameFn != nullptr);
   g_driver_gl.debug_fn.glGetProgramResourceNameFn(program, programInterface,
                                                   index, bufSize, length, name);
 }
 
 static void GL_BINDING_CALL Debug_glGetQueryiv(GLenum target,
                                                GLenum pname,
                                                GLint* params) {
   GL_SERVICE_LOG("glGetQueryiv"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetQueryivFn != nullptr);
   g_driver_gl.debug_fn.glGetQueryivFn(target, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetQueryObjecti64v(GLuint id,
                                                        GLenum pname,
                                                        GLint64* params) {
   GL_SERVICE_LOG("glGetQueryObjecti64v"
                  << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetQueryObjecti64vFn != nullptr);
   g_driver_gl.debug_fn.glGetQueryObjecti64vFn(id, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetQueryObjectiv(GLuint id,
                                                      GLenum pname,
                                                      GLint* params) {
   GL_SERVICE_LOG("glGetQueryObjectiv"
                  << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetQueryObjectivFn != nullptr);
   g_driver_gl.debug_fn.glGetQueryObjectivFn(id, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetQueryObjectui64v(GLuint id,
                                                         GLenum pname,
                                                         GLuint64* params) {
   GL_SERVICE_LOG("glGetQueryObjectui64v"
                  << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetQueryObjectui64vFn != nullptr);
   g_driver_gl.debug_fn.glGetQueryObjectui64vFn(id, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetQueryObjectuiv(GLuint id,
                                                       GLenum pname,
                                                       GLuint* params) {
   GL_SERVICE_LOG("glGetQueryObjectuiv"
                  << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetQueryObjectuivFn != nullptr);
   g_driver_gl.debug_fn.glGetQueryObjectuivFn(id, pname, params);
 }
 
 static void GL_BINDING_CALL
 Debug_glGetRenderbufferParameterivEXT(GLenum target,
                                       GLenum pname,
                                       GLint* params) {
   GL_SERVICE_LOG("glGetRenderbufferParameterivEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetRenderbufferParameterivEXTFn != nullptr);
   g_driver_gl.debug_fn.glGetRenderbufferParameterivEXTFn(target, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetSamplerParameterfv(GLuint sampler,
                                                           GLenum pname,
                                                           GLfloat* params) {
   GL_SERVICE_LOG("glGetSamplerParameterfv"
                  << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetSamplerParameterfvFn != nullptr);
   g_driver_gl.debug_fn.glGetSamplerParameterfvFn(sampler, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetSamplerParameteriv(GLuint sampler,
                                                           GLenum pname,
                                                           GLint* params) {
   GL_SERVICE_LOG("glGetSamplerParameteriv"
                  << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetSamplerParameterivFn != nullptr);
   g_driver_gl.debug_fn.glGetSamplerParameterivFn(sampler, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetShaderInfoLog(GLuint shader,
                                                      GLsizei bufsize,
                                                      GLsizei* length,
                                                      char* infolog) {
   GL_SERVICE_LOG("glGetShaderInfoLog"
                  << "(" << shader << ", " << bufsize << ", "
                  << static_cast<const void*>(length) << ", "
                  << static_cast<const void*>(infolog) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetShaderInfoLogFn != nullptr);
   g_driver_gl.debug_fn.glGetShaderInfoLogFn(shader, bufsize, length, infolog);
 }
 
 static void GL_BINDING_CALL Debug_glGetShaderiv(GLuint shader,
                                                 GLenum pname,
                                                 GLint* params) {
   GL_SERVICE_LOG("glGetShaderiv"
                  << "(" << shader << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetShaderivFn != nullptr);
   g_driver_gl.debug_fn.glGetShaderivFn(shader, pname, params);
 }
 
 static void GL_BINDING_CALL
 Debug_glGetShaderPrecisionFormat(GLenum shadertype,
                                  GLenum precisiontype,
                                  GLint* range,
                                  GLint* precision) {
   GL_SERVICE_LOG("glGetShaderPrecisionFormat"
                  << "(" << GLEnums::GetStringEnum(shadertype) << ", "
                  << GLEnums::GetStringEnum(precisiontype) << ", "
                  << static_cast<const void*>(range) << ", "
                  << static_cast<const void*>(precision) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetShaderPrecisionFormatFn != nullptr);
   g_driver_gl.debug_fn.glGetShaderPrecisionFormatFn(shadertype, precisiontype,
                                                     range, precision);
 }
 
 static void GL_BINDING_CALL Debug_glGetShaderSource(GLuint shader,
                                                     GLsizei bufsize,
                                                     GLsizei* length,
                                                     char* source) {
   GL_SERVICE_LOG("glGetShaderSource"
                  << "(" << shader << ", " << bufsize << ", "
                  << static_cast<const void*>(length) << ", "
                  << static_cast<const void*>(source) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetShaderSourceFn != nullptr);
   g_driver_gl.debug_fn.glGetShaderSourceFn(shader, bufsize, length, source);
 }
 
 static const GLubyte* GL_BINDING_CALL Debug_glGetString(GLenum name) {
   GL_SERVICE_LOG("glGetString"
                  << "(" << GLEnums::GetStringEnum(name) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetStringFn != nullptr);
   const GLubyte* result = g_driver_gl.debug_fn.glGetStringFn(name);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static const GLubyte* GL_BINDING_CALL Debug_glGetStringi(GLenum name,
                                                          GLuint index) {
   GL_SERVICE_LOG("glGetStringi"
                  << "(" << GLEnums::GetStringEnum(name) << ", " << index
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetStringiFn != nullptr);
   const GLubyte* result = g_driver_gl.debug_fn.glGetStringiFn(name, index);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glGetSynciv(GLsync sync,
                                               GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei* length,
                                               GLint* values) {
   GL_SERVICE_LOG("glGetSynciv"
                  << "(" << sync << ", " << GLEnums::GetStringEnum(pname) << ", "
                  << bufSize << ", " << static_cast<const void*>(length) << ", "
                  << static_cast<const void*>(values) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetSyncivFn != nullptr);
   g_driver_gl.debug_fn.glGetSyncivFn(sync, pname, bufSize, length, values);
 }
 
 static void GL_BINDING_CALL Debug_glGetTexLevelParameterfv(GLenum target,
                                                            GLint level,
                                                            GLenum pname,
                                                            GLfloat* params) {
   GL_SERVICE_LOG("glGetTexLevelParameterfv"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetTexLevelParameterfvFn != nullptr);
   g_driver_gl.debug_fn.glGetTexLevelParameterfvFn(target, level, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetTexLevelParameteriv(GLenum target,
                                                            GLint level,
                                                            GLenum pname,
                                                            GLint* params) {
   GL_SERVICE_LOG("glGetTexLevelParameteriv"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetTexLevelParameterivFn != nullptr);
   g_driver_gl.debug_fn.glGetTexLevelParameterivFn(target, level, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetTexParameterfv(GLenum target,
                                                       GLenum pname,
                                                       GLfloat* params) {
   GL_SERVICE_LOG("glGetTexParameterfv"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetTexParameterfvFn != nullptr);
   g_driver_gl.debug_fn.glGetTexParameterfvFn(target, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetTexParameteriv(GLenum target,
                                                       GLenum pname,
                                                       GLint* params) {
   GL_SERVICE_LOG("glGetTexParameteriv"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetTexParameterivFn != nullptr);
   g_driver_gl.debug_fn.glGetTexParameterivFn(target, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetTransformFeedbackVarying(GLuint program,
                                                                 GLuint index,
                                                                 GLsizei bufSize,
                                                                 GLsizei* length,
                                                                 GLsizei* size,
                                                                 GLenum* type,
                                                                 char* name) {
   GL_SERVICE_LOG("glGetTransformFeedbackVarying"
                  << "(" << program << ", " << index << ", " << bufSize << ", "
                  << static_cast<const void*>(length) << ", "
                  << static_cast<const void*>(size) << ", "
                  << static_cast<const void*>(type) << ", "
                  << static_cast<const void*>(name) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetTransformFeedbackVaryingFn != nullptr);
   g_driver_gl.debug_fn.glGetTransformFeedbackVaryingFn(
       program, index, bufSize, length, size, type, name);
 }
 
 static void GL_BINDING_CALL
 Debug_glGetTranslatedShaderSourceANGLE(GLuint shader,
                                        GLsizei bufsize,
                                        GLsizei* length,
                                        char* source) {
   GL_SERVICE_LOG("glGetTranslatedShaderSourceANGLE"
                  << "(" << shader << ", " << bufsize << ", "
                  << static_cast<const void*>(length) << ", "
                  << static_cast<const void*>(source) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetTranslatedShaderSourceANGLEFn != nullptr);
   g_driver_gl.debug_fn.glGetTranslatedShaderSourceANGLEFn(shader, bufsize,
                                                           length, source);
 }
 
 static GLuint GL_BINDING_CALL
 Debug_glGetUniformBlockIndex(GLuint program, const char* uniformBlockName) {
   GL_SERVICE_LOG("glGetUniformBlockIndex"
                  << "(" << program << ", " << uniformBlockName << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetUniformBlockIndexFn != nullptr);
   GLuint result =
       g_driver_gl.debug_fn.glGetUniformBlockIndexFn(program, uniformBlockName);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glGetUniformfv(GLuint program,
                                                  GLint location,
                                                  GLfloat* params) {
   GL_SERVICE_LOG("glGetUniformfv"
                  << "(" << program << ", " << location << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetUniformfvFn != nullptr);
   g_driver_gl.debug_fn.glGetUniformfvFn(program, location, params);
 }
 
 static void GL_BINDING_CALL
 Debug_glGetUniformIndices(GLuint program,
                           GLsizei uniformCount,
                           const char* const* uniformNames,
                           GLuint* uniformIndices) {
   GL_SERVICE_LOG("glGetUniformIndices"
                  << "(" << program << ", " << uniformCount << ", "
                  << static_cast<const void*>(uniformNames) << ", "
                  << static_cast<const void*>(uniformIndices) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetUniformIndicesFn != nullptr);
   g_driver_gl.debug_fn.glGetUniformIndicesFn(program, uniformCount,
                                              uniformNames, uniformIndices);
 }
 
 static void GL_BINDING_CALL Debug_glGetUniformiv(GLuint program,
                                                  GLint location,
                                                  GLint* params) {
   GL_SERVICE_LOG("glGetUniformiv"
                  << "(" << program << ", " << location << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetUniformivFn != nullptr);
   g_driver_gl.debug_fn.glGetUniformivFn(program, location, params);
 }
 
 static GLint GL_BINDING_CALL Debug_glGetUniformLocation(GLuint program,
                                                         const char* name) {
   GL_SERVICE_LOG("glGetUniformLocation"
                  << "(" << program << ", " << name << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetUniformLocationFn != nullptr);
   GLint result = g_driver_gl.debug_fn.glGetUniformLocationFn(program, name);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glGetUniformuiv(GLuint program,
                                                   GLint location,
                                                   GLuint* params) {
   GL_SERVICE_LOG("glGetUniformuiv"
                  << "(" << program << ", " << location << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetUniformuivFn != nullptr);
   g_driver_gl.debug_fn.glGetUniformuivFn(program, location, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetVertexAttribfv(GLuint index,
                                                       GLenum pname,
                                                       GLfloat* params) {
   GL_SERVICE_LOG("glGetVertexAttribfv"
                  << "(" << index << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetVertexAttribfvFn != nullptr);
   g_driver_gl.debug_fn.glGetVertexAttribfvFn(index, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetVertexAttribiv(GLuint index,
                                                       GLenum pname,
                                                       GLint* params) {
   GL_SERVICE_LOG("glGetVertexAttribiv"
                  << "(" << index << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetVertexAttribivFn != nullptr);
   g_driver_gl.debug_fn.glGetVertexAttribivFn(index, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glGetVertexAttribPointerv(GLuint index,
                                                             GLenum pname,
                                                             void** pointer) {
   GL_SERVICE_LOG("glGetVertexAttribPointerv"
                  << "(" << index << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << pointer << ")");
+  DCHECK(g_driver_gl.debug_fn.glGetVertexAttribPointervFn != nullptr);
   g_driver_gl.debug_fn.glGetVertexAttribPointervFn(index, pname, pointer);
 }
 
 static void GL_BINDING_CALL Debug_glHint(GLenum target, GLenum mode) {
   GL_SERVICE_LOG("glHint"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(mode) << ")");
+  DCHECK(g_driver_gl.debug_fn.glHintFn != nullptr);
   g_driver_gl.debug_fn.glHintFn(target, mode);
 }
 
 static void GL_BINDING_CALL Debug_glInsertEventMarkerEXT(GLsizei length,
                                                          const char* marker) {
   GL_SERVICE_LOG("glInsertEventMarkerEXT"
                  << "(" << length << ", " << marker << ")");
+  DCHECK(g_driver_gl.debug_fn.glInsertEventMarkerEXTFn != nullptr);
   g_driver_gl.debug_fn.glInsertEventMarkerEXTFn(length, marker);
 }
 
 static void GL_BINDING_CALL
 Debug_glInvalidateFramebuffer(GLenum target,
                               GLsizei numAttachments,
                               const GLenum* attachments) {
   GL_SERVICE_LOG("glInvalidateFramebuffer"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << numAttachments << ", "
                  << static_cast<const void*>(attachments) << ")");
+  DCHECK(g_driver_gl.debug_fn.glInvalidateFramebufferFn != nullptr);
   g_driver_gl.debug_fn.glInvalidateFramebufferFn(target, numAttachments,
                                                  attachments);
 }
 
 static void GL_BINDING_CALL
 Debug_glInvalidateSubFramebuffer(GLenum target,
                                  GLsizei numAttachments,
                                  const GLenum* attachments,
                                  GLint x,
                                  GLint y,
                                  GLint width,
                                  GLint height) {
   GL_SERVICE_LOG("glInvalidateSubFramebuffer"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << numAttachments << ", "
                  << static_cast<const void*>(attachments) << ", " << x << ", "
                  << y << ", " << width << ", " << height << ")");
+  DCHECK(g_driver_gl.debug_fn.glInvalidateSubFramebufferFn != nullptr);
   g_driver_gl.debug_fn.glInvalidateSubFramebufferFn(
       target, numAttachments, attachments, x, y, width, height);
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsBuffer(GLuint buffer) {
   GL_SERVICE_LOG("glIsBuffer"
                  << "(" << buffer << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsBufferFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsBufferFn(buffer);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsEnabled(GLenum cap) {
   GL_SERVICE_LOG("glIsEnabled"
                  << "(" << GLEnums::GetStringEnum(cap) << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsEnabledFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsEnabledFn(cap);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsFenceAPPLE(GLuint fence) {
   GL_SERVICE_LOG("glIsFenceAPPLE"
                  << "(" << fence << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsFenceAPPLEFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsFenceAPPLEFn(fence);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsFenceNV(GLuint fence) {
   GL_SERVICE_LOG("glIsFenceNV"
                  << "(" << fence << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsFenceNVFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsFenceNVFn(fence);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsFramebufferEXT(GLuint framebuffer) {
   GL_SERVICE_LOG("glIsFramebufferEXT"
                  << "(" << framebuffer << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsFramebufferEXTFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsFramebufferEXTFn(framebuffer);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsPathNV(GLuint path) {
   GL_SERVICE_LOG("glIsPathNV"
                  << "(" << path << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsPathNVFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsPathNVFn(path);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsProgram(GLuint program) {
   GL_SERVICE_LOG("glIsProgram"
                  << "(" << program << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsProgramFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsProgramFn(program);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsQuery(GLuint query) {
   GL_SERVICE_LOG("glIsQuery"
                  << "(" << query << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsQueryFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsQueryFn(query);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL
 Debug_glIsRenderbufferEXT(GLuint renderbuffer) {
   GL_SERVICE_LOG("glIsRenderbufferEXT"
                  << "(" << renderbuffer << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsRenderbufferEXTFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsRenderbufferEXTFn(renderbuffer);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsSampler(GLuint sampler) {
   GL_SERVICE_LOG("glIsSampler"
                  << "(" << sampler << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsSamplerFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsSamplerFn(sampler);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsShader(GLuint shader) {
   GL_SERVICE_LOG("glIsShader"
                  << "(" << shader << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsShaderFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsShaderFn(shader);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsSync(GLsync sync) {
   GL_SERVICE_LOG("glIsSync"
                  << "(" << sync << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsSyncFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsSyncFn(sync);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsTexture(GLuint texture) {
   GL_SERVICE_LOG("glIsTexture"
                  << "(" << texture << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsTextureFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsTextureFn(texture);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsTransformFeedback(GLuint id) {
   GL_SERVICE_LOG("glIsTransformFeedback"
                  << "(" << id << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsTransformFeedbackFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsTransformFeedbackFn(id);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glIsVertexArrayOES(GLuint array) {
   GL_SERVICE_LOG("glIsVertexArrayOES"
                  << "(" << array << ")");
+  DCHECK(g_driver_gl.debug_fn.glIsVertexArrayOESFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glIsVertexArrayOESFn(array);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glLineWidth(GLfloat width) {
   GL_SERVICE_LOG("glLineWidth"
                  << "(" << width << ")");
+  DCHECK(g_driver_gl.debug_fn.glLineWidthFn != nullptr);
   g_driver_gl.debug_fn.glLineWidthFn(width);
 }
 
 static void GL_BINDING_CALL Debug_glLinkProgram(GLuint program) {
   GL_SERVICE_LOG("glLinkProgram"
                  << "(" << program << ")");
+  DCHECK(g_driver_gl.debug_fn.glLinkProgramFn != nullptr);
   g_driver_gl.debug_fn.glLinkProgramFn(program);
 }
 
 static void* GL_BINDING_CALL Debug_glMapBuffer(GLenum target, GLenum access) {
   GL_SERVICE_LOG("glMapBuffer"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(access) << ")");
+  DCHECK(g_driver_gl.debug_fn.glMapBufferFn != nullptr);
   void* result = g_driver_gl.debug_fn.glMapBufferFn(target, access);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void* GL_BINDING_CALL Debug_glMapBufferRange(GLenum target,
                                                     GLintptr offset,
                                                     GLsizeiptr length,
                                                     GLbitfield access) {
   GL_SERVICE_LOG("glMapBufferRange"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << offset
                  << ", " << length << ", " << access << ")");
+  DCHECK(g_driver_gl.debug_fn.glMapBufferRangeFn != nullptr);
   void* result =
       g_driver_gl.debug_fn.glMapBufferRangeFn(target, offset, length, access);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glMatrixLoadfEXT(GLenum matrixMode,
                                                    const GLfloat* m) {
   GL_SERVICE_LOG("glMatrixLoadfEXT"
                  << "(" << GLEnums::GetStringEnum(matrixMode) << ", "
                  << static_cast<const void*>(m) << ")");
+  DCHECK(g_driver_gl.debug_fn.glMatrixLoadfEXTFn != nullptr);
   g_driver_gl.debug_fn.glMatrixLoadfEXTFn(matrixMode, m);
 }
 
 static void GL_BINDING_CALL Debug_glMatrixLoadIdentityEXT(GLenum matrixMode) {
   GL_SERVICE_LOG("glMatrixLoadIdentityEXT"
                  << "(" << GLEnums::GetStringEnum(matrixMode) << ")");
+  DCHECK(g_driver_gl.debug_fn.glMatrixLoadIdentityEXTFn != nullptr);
   g_driver_gl.debug_fn.glMatrixLoadIdentityEXTFn(matrixMode);
 }
 
 static void GL_BINDING_CALL Debug_glMemoryBarrierEXT(GLbitfield barriers) {
   GL_SERVICE_LOG("glMemoryBarrierEXT"
                  << "(" << barriers << ")");
+  DCHECK(g_driver_gl.debug_fn.glMemoryBarrierEXTFn != nullptr);
   g_driver_gl.debug_fn.glMemoryBarrierEXTFn(barriers);
 }
 
 static void GL_BINDING_CALL Debug_glPathCommandsNV(GLuint path,
                                                    GLsizei numCommands,
                                                    const GLubyte* commands,
                                                    GLsizei numCoords,
                                                    GLenum coordType,
                                                    const GLvoid* coords) {
   GL_SERVICE_LOG("glPathCommandsNV"
                  << "(" << path << ", " << numCommands << ", "
                  << static_cast<const void*>(commands) << ", " << numCoords
                  << ", " << GLEnums::GetStringEnum(coordType) << ", "
                  << static_cast<const void*>(coords) << ")");
+  DCHECK(g_driver_gl.debug_fn.glPathCommandsNVFn != nullptr);
   g_driver_gl.debug_fn.glPathCommandsNVFn(path, numCommands, commands,
                                           numCoords, coordType, coords);
 }
 
 static void GL_BINDING_CALL Debug_glPathParameterfNV(GLuint path,
                                                      GLenum pname,
                                                      GLfloat value) {
   GL_SERVICE_LOG("glPathParameterfNV"
                  << "(" << path << ", " << GLEnums::GetStringEnum(pname) << ", "
                  << value << ")");
+  DCHECK(g_driver_gl.debug_fn.glPathParameterfNVFn != nullptr);
   g_driver_gl.debug_fn.glPathParameterfNVFn(path, pname, value);
 }
 
 static void GL_BINDING_CALL Debug_glPathParameteriNV(GLuint path,
                                                      GLenum pname,
                                                      GLint value) {
   GL_SERVICE_LOG("glPathParameteriNV"
                  << "(" << path << ", " << GLEnums::GetStringEnum(pname) << ", "
                  << value << ")");
+  DCHECK(g_driver_gl.debug_fn.glPathParameteriNVFn != nullptr);
   g_driver_gl.debug_fn.glPathParameteriNVFn(path, pname, value);
 }
 
 static void GL_BINDING_CALL Debug_glPathStencilFuncNV(GLenum func,
                                                       GLint ref,
                                                       GLuint mask) {
   GL_SERVICE_LOG("glPathStencilFuncNV"
                  << "(" << GLEnums::GetStringEnum(func) << ", " << ref << ", "
                  << mask << ")");
+  DCHECK(g_driver_gl.debug_fn.glPathStencilFuncNVFn != nullptr);
   g_driver_gl.debug_fn.glPathStencilFuncNVFn(func, ref, mask);
 }
 
 static void GL_BINDING_CALL Debug_glPauseTransformFeedback(void) {
   GL_SERVICE_LOG("glPauseTransformFeedback"
                  << "("
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glPauseTransformFeedbackFn != nullptr);
   g_driver_gl.debug_fn.glPauseTransformFeedbackFn();
 }
 
 static void GL_BINDING_CALL Debug_glPixelStorei(GLenum pname, GLint param) {
   GL_SERVICE_LOG("glPixelStorei"
                  << "(" << GLEnums::GetStringEnum(pname) << ", " << param
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glPixelStoreiFn != nullptr);
   g_driver_gl.debug_fn.glPixelStoreiFn(pname, param);
 }
 
 static void GL_BINDING_CALL Debug_glPointParameteri(GLenum pname, GLint param) {
   GL_SERVICE_LOG("glPointParameteri"
                  << "(" << GLEnums::GetStringEnum(pname) << ", " << param
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glPointParameteriFn != nullptr);
   g_driver_gl.debug_fn.glPointParameteriFn(pname, param);
 }
 
 static void GL_BINDING_CALL Debug_glPolygonOffset(GLfloat factor,
                                                   GLfloat units) {
   GL_SERVICE_LOG("glPolygonOffset"
                  << "(" << factor << ", " << units << ")");
+  DCHECK(g_driver_gl.debug_fn.glPolygonOffsetFn != nullptr);
   g_driver_gl.debug_fn.glPolygonOffsetFn(factor, units);
 }
 
 static void GL_BINDING_CALL Debug_glPopGroupMarkerEXT(void) {
   GL_SERVICE_LOG("glPopGroupMarkerEXT"
                  << "("
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glPopGroupMarkerEXTFn != nullptr);
   g_driver_gl.debug_fn.glPopGroupMarkerEXTFn();
 }
 
 static void GL_BINDING_CALL Debug_glProgramBinary(GLuint program,
                                                   GLenum binaryFormat,
                                                   const GLvoid* binary,
                                                   GLsizei length) {
   GL_SERVICE_LOG("glProgramBinary"
                  << "(" << program << ", "
                  << GLEnums::GetStringEnum(binaryFormat) << ", "
                  << static_cast<const void*>(binary) << ", " << length << ")");
+  DCHECK(g_driver_gl.debug_fn.glProgramBinaryFn != nullptr);
   g_driver_gl.debug_fn.glProgramBinaryFn(program, binaryFormat, binary, length);
 }
 
 static void GL_BINDING_CALL Debug_glProgramParameteri(GLuint program,
                                                       GLenum pname,
                                                       GLint value) {
   GL_SERVICE_LOG("glProgramParameteri"
                  << "(" << program << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << value << ")");
+  DCHECK(g_driver_gl.debug_fn.glProgramParameteriFn != nullptr);
   g_driver_gl.debug_fn.glProgramParameteriFn(program, pname, value);
 }
 
 static void GL_BINDING_CALL
 Debug_glProgramPathFragmentInputGenNV(GLuint program,
                                       GLint location,
                                       GLenum genMode,
                                       GLint components,
                                       const GLfloat* coeffs) {
   GL_SERVICE_LOG("glProgramPathFragmentInputGenNV"
                  << "(" << program << ", " << location << ", "
                  << GLEnums::GetStringEnum(genMode) << ", " << components
                  << ", " << static_cast<const void*>(coeffs) << ")");
+  DCHECK(g_driver_gl.debug_fn.glProgramPathFragmentInputGenNVFn != nullptr);
   g_driver_gl.debug_fn.glProgramPathFragmentInputGenNVFn(
       program, location, genMode, components, coeffs);
 }
 
 static void GL_BINDING_CALL Debug_glPushGroupMarkerEXT(GLsizei length,
                                                        const char* marker) {
   GL_SERVICE_LOG("glPushGroupMarkerEXT"
                  << "(" << length << ", " << marker << ")");
+  DCHECK(g_driver_gl.debug_fn.glPushGroupMarkerEXTFn != nullptr);
   g_driver_gl.debug_fn.glPushGroupMarkerEXTFn(length, marker);
 }
 
 static void GL_BINDING_CALL Debug_glQueryCounter(GLuint id, GLenum target) {
   GL_SERVICE_LOG("glQueryCounter"
                  << "(" << id << ", " << GLEnums::GetStringEnum(target) << ")");
+  DCHECK(g_driver_gl.debug_fn.glQueryCounterFn != nullptr);
   g_driver_gl.debug_fn.glQueryCounterFn(id, target);
 }
 
 static void GL_BINDING_CALL Debug_glReadBuffer(GLenum src) {
   GL_SERVICE_LOG("glReadBuffer"
                  << "(" << GLEnums::GetStringEnum(src) << ")");
+  DCHECK(g_driver_gl.debug_fn.glReadBufferFn != nullptr);
   g_driver_gl.debug_fn.glReadBufferFn(src);
 }
 
 static void GL_BINDING_CALL Debug_glReadPixels(GLint x,
                                                GLint y,
                                                GLsizei width,
                                                GLsizei height,
                                                GLenum format,
                                                GLenum type,
                                                void* pixels) {
   GL_SERVICE_LOG("glReadPixels"
                  << "(" << x << ", " << y << ", " << width << ", " << height
                  << ", " << GLEnums::GetStringEnum(format) << ", "
                  << GLEnums::GetStringEnum(type) << ", "
                  << static_cast<const void*>(pixels) << ")");
+  DCHECK(g_driver_gl.debug_fn.glReadPixelsFn != nullptr);
   g_driver_gl.debug_fn.glReadPixelsFn(x, y, width, height, format, type,
                                       pixels);
 }
 
 static void GL_BINDING_CALL Debug_glReleaseShaderCompiler(void) {
   GL_SERVICE_LOG("glReleaseShaderCompiler"
                  << "("
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glReleaseShaderCompilerFn != nullptr);
   g_driver_gl.debug_fn.glReleaseShaderCompilerFn();
 }
 
 static void GL_BINDING_CALL
 Debug_glRenderbufferStorageEXT(GLenum target,
                                GLenum internalformat,
                                GLsizei width,
                                GLsizei height) {
   GL_SERVICE_LOG("glRenderbufferStorageEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(internalformat) << ", " << width
                  << ", " << height << ")");
+  DCHECK(g_driver_gl.debug_fn.glRenderbufferStorageEXTFn != nullptr);
   g_driver_gl.debug_fn.glRenderbufferStorageEXTFn(target, internalformat, width,
                                                   height);
 }
 
 static void GL_BINDING_CALL
 Debug_glRenderbufferStorageMultisample(GLenum target,
                                        GLsizei samples,
                                        GLenum internalformat,
                                        GLsizei width,
                                        GLsizei height) {
   GL_SERVICE_LOG("glRenderbufferStorageMultisample"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << samples
                  << ", " << GLEnums::GetStringEnum(internalformat) << ", "
                  << width << ", " << height << ")");
+  DCHECK(g_driver_gl.debug_fn.glRenderbufferStorageMultisampleFn != nullptr);
   g_driver_gl.debug_fn.glRenderbufferStorageMultisampleFn(
       target, samples, internalformat, width, height);
 }
 
 static void GL_BINDING_CALL
 Debug_glRenderbufferStorageMultisampleANGLE(GLenum target,
                                             GLsizei samples,
                                             GLenum internalformat,
                                             GLsizei width,
                                             GLsizei height) {
   GL_SERVICE_LOG("glRenderbufferStorageMultisampleANGLE"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << samples
                  << ", " << GLEnums::GetStringEnum(internalformat) << ", "
                  << width << ", " << height << ")");
+  DCHECK(g_driver_gl.debug_fn.glRenderbufferStorageMultisampleANGLEFn !=
+         nullptr);
   g_driver_gl.debug_fn.glRenderbufferStorageMultisampleANGLEFn(
       target, samples, internalformat, width, height);
 }
 
 static void GL_BINDING_CALL
 Debug_glRenderbufferStorageMultisampleEXT(GLenum target,
                                           GLsizei samples,
                                           GLenum internalformat,
                                           GLsizei width,
                                           GLsizei height) {
   GL_SERVICE_LOG("glRenderbufferStorageMultisampleEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << samples
                  << ", " << GLEnums::GetStringEnum(internalformat) << ", "
                  << width << ", " << height << ")");
+  DCHECK(g_driver_gl.debug_fn.glRenderbufferStorageMultisampleEXTFn != nullptr);
   g_driver_gl.debug_fn.glRenderbufferStorageMultisampleEXTFn(
       target, samples, internalformat, width, height);
 }
 
 static void GL_BINDING_CALL
 Debug_glRenderbufferStorageMultisampleIMG(GLenum target,
                                           GLsizei samples,
                                           GLenum internalformat,
                                           GLsizei width,
                                           GLsizei height) {
   GL_SERVICE_LOG("glRenderbufferStorageMultisampleIMG"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << samples
                  << ", " << GLEnums::GetStringEnum(internalformat) << ", "
                  << width << ", " << height << ")");
+  DCHECK(g_driver_gl.debug_fn.glRenderbufferStorageMultisampleIMGFn != nullptr);
   g_driver_gl.debug_fn.glRenderbufferStorageMultisampleIMGFn(
       target, samples, internalformat, width, height);
 }
 
 static void GL_BINDING_CALL Debug_glResumeTransformFeedback(void) {
   GL_SERVICE_LOG("glResumeTransformFeedback"
                  << "("
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glResumeTransformFeedbackFn != nullptr);
   g_driver_gl.debug_fn.glResumeTransformFeedbackFn();
 }
 
 static void GL_BINDING_CALL Debug_glSampleCoverage(GLclampf value,
                                                    GLboolean invert) {
   GL_SERVICE_LOG("glSampleCoverage"
                  << "(" << value << ", " << GLEnums::GetStringBool(invert)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glSampleCoverageFn != nullptr);
   g_driver_gl.debug_fn.glSampleCoverageFn(value, invert);
 }
 
 static void GL_BINDING_CALL Debug_glSamplerParameterf(GLuint sampler,
                                                       GLenum pname,
                                                       GLfloat param) {
   GL_SERVICE_LOG("glSamplerParameterf"
                  << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << param << ")");
+  DCHECK(g_driver_gl.debug_fn.glSamplerParameterfFn != nullptr);
   g_driver_gl.debug_fn.glSamplerParameterfFn(sampler, pname, param);
 }
 
 static void GL_BINDING_CALL Debug_glSamplerParameterfv(GLuint sampler,
                                                        GLenum pname,
                                                        const GLfloat* params) {
   GL_SERVICE_LOG("glSamplerParameterfv"
                  << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glSamplerParameterfvFn != nullptr);
   g_driver_gl.debug_fn.glSamplerParameterfvFn(sampler, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glSamplerParameteri(GLuint sampler,
                                                       GLenum pname,
                                                       GLint param) {
   GL_SERVICE_LOG("glSamplerParameteri"
                  << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << param << ")");
+  DCHECK(g_driver_gl.debug_fn.glSamplerParameteriFn != nullptr);
   g_driver_gl.debug_fn.glSamplerParameteriFn(sampler, pname, param);
 }
 
 static void GL_BINDING_CALL Debug_glSamplerParameteriv(GLuint sampler,
                                                        GLenum pname,
                                                        const GLint* params) {
   GL_SERVICE_LOG("glSamplerParameteriv"
                  << "(" << sampler << ", " << GLEnums::GetStringEnum(pname)
                  << ", " << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glSamplerParameterivFn != nullptr);
   g_driver_gl.debug_fn.glSamplerParameterivFn(sampler, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glScissor(GLint x,
                                             GLint y,
                                             GLsizei width,
                                             GLsizei height) {
   GL_SERVICE_LOG("glScissor"
                  << "(" << x << ", " << y << ", " << width << ", " << height
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glScissorFn != nullptr);
   g_driver_gl.debug_fn.glScissorFn(x, y, width, height);
 }
 
 static void GL_BINDING_CALL Debug_glSetFenceAPPLE(GLuint fence) {
   GL_SERVICE_LOG("glSetFenceAPPLE"
                  << "(" << fence << ")");
+  DCHECK(g_driver_gl.debug_fn.glSetFenceAPPLEFn != nullptr);
   g_driver_gl.debug_fn.glSetFenceAPPLEFn(fence);
 }
 
 static void GL_BINDING_CALL Debug_glSetFenceNV(GLuint fence, GLenum condition) {
   GL_SERVICE_LOG("glSetFenceNV"
                  << "(" << fence << ", " << GLEnums::GetStringEnum(condition)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glSetFenceNVFn != nullptr);
   g_driver_gl.debug_fn.glSetFenceNVFn(fence, condition);
 }
 
 static void GL_BINDING_CALL Debug_glShaderBinary(GLsizei n,
                                                  const GLuint* shaders,
                                                  GLenum binaryformat,
                                                  const void* binary,
                                                  GLsizei length) {
   GL_SERVICE_LOG("glShaderBinary"
                  << "(" << n << ", " << static_cast<const void*>(shaders)
                  << ", " << GLEnums::GetStringEnum(binaryformat) << ", "
                  << static_cast<const void*>(binary) << ", " << length << ")");
+  DCHECK(g_driver_gl.debug_fn.glShaderBinaryFn != nullptr);
   g_driver_gl.debug_fn.glShaderBinaryFn(n, shaders, binaryformat, binary,
                                         length);
 }
 
 static void GL_BINDING_CALL Debug_glShaderSource(GLuint shader,
                                                  GLsizei count,
                                                  const char* const* str,
                                                  const GLint* length) {
   GL_SERVICE_LOG("glShaderSource"
                  << "(" << shader << ", " << count << ", "
                  << static_cast<const void*>(str) << ", "
                  << static_cast<const void*>(length) << ")");
+  DCHECK(g_driver_gl.debug_fn.glShaderSourceFn != nullptr);
   g_driver_gl.debug_fn.glShaderSourceFn(shader, count, str, length);
 
   GL_SERVICE_LOG_CODE_BLOCK({
     for (GLsizei ii = 0; ii < count; ++ii) {
       if (str[ii]) {
         if (length && length[ii] >= 0) {
           std::string source(str[ii], length[ii]);
           GL_SERVICE_LOG("  " << ii << ": ---\n" << source << "\n---");
         } else {
           GL_SERVICE_LOG("  " << ii << ": ---\n" << str[ii] << "\n---");
@@ skipping 14 matching lines @@
                                    GLuint mask,
                                    GLenum transformType,
                                    const GLfloat* transformValues) {
   GL_SERVICE_LOG("glStencilFillPathInstancedNV"
                  << "(" << numPaths << ", "
                  << GLEnums::GetStringEnum(pathNameType) << ", "
                  << static_cast<const void*>(paths) << ", " << pathBase << ", "
                  << GLEnums::GetStringEnum(fillMode) << ", " << mask << ", "
                  << GLEnums::GetStringEnum(transformType) << ", "
                  << static_cast<const void*>(transformValues) << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilFillPathInstancedNVFn != nullptr);
   g_driver_gl.debug_fn.glStencilFillPathInstancedNVFn(
       numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType,
       transformValues);
 }
 
 static void GL_BINDING_CALL Debug_glStencilFillPathNV(GLuint path,
                                                       GLenum fillMode,
                                                       GLuint mask) {
   GL_SERVICE_LOG("glStencilFillPathNV"
                  << "(" << path << ", " << GLEnums::GetStringEnum(fillMode)
                  << ", " << mask << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilFillPathNVFn != nullptr);
   g_driver_gl.debug_fn.glStencilFillPathNVFn(path, fillMode, mask);
 }
 
 static void GL_BINDING_CALL Debug_glStencilFunc(GLenum func,
                                                 GLint ref,
                                                 GLuint mask) {
   GL_SERVICE_LOG("glStencilFunc"
                  << "(" << GLEnums::GetStringEnum(func) << ", " << ref << ", "
                  << mask << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilFuncFn != nullptr);
   g_driver_gl.debug_fn.glStencilFuncFn(func, ref, mask);
 }
 
 static void GL_BINDING_CALL Debug_glStencilFuncSeparate(GLenum face,
                                                         GLenum func,
                                                         GLint ref,
                                                         GLuint mask) {
   GL_SERVICE_LOG("glStencilFuncSeparate"
                  << "(" << GLEnums::GetStringEnum(face) << ", "
                  << GLEnums::GetStringEnum(func) << ", " << ref << ", " << mask
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilFuncSeparateFn != nullptr);
   g_driver_gl.debug_fn.glStencilFuncSeparateFn(face, func, ref, mask);
 }
 
 static void GL_BINDING_CALL Debug_glStencilMask(GLuint mask) {
   GL_SERVICE_LOG("glStencilMask"
                  << "(" << mask << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilMaskFn != nullptr);
   g_driver_gl.debug_fn.glStencilMaskFn(mask);
 }
 
 static void GL_BINDING_CALL Debug_glStencilMaskSeparate(GLenum face,
                                                         GLuint mask) {
   GL_SERVICE_LOG("glStencilMaskSeparate"
                  << "(" << GLEnums::GetStringEnum(face) << ", " << mask << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilMaskSeparateFn != nullptr);
   g_driver_gl.debug_fn.glStencilMaskSeparateFn(face, mask);
 }
 
 static void GL_BINDING_CALL Debug_glStencilOp(GLenum fail,
                                               GLenum zfail,
                                               GLenum zpass) {
   GL_SERVICE_LOG("glStencilOp"
                  << "(" << GLEnums::GetStringEnum(fail) << ", "
                  << GLEnums::GetStringEnum(zfail) << ", "
                  << GLEnums::GetStringEnum(zpass) << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilOpFn != nullptr);
   g_driver_gl.debug_fn.glStencilOpFn(fail, zfail, zpass);
 }
 
 static void GL_BINDING_CALL Debug_glStencilOpSeparate(GLenum face,
                                                       GLenum fail,
                                                       GLenum zfail,
                                                       GLenum zpass) {
   GL_SERVICE_LOG("glStencilOpSeparate"
                  << "(" << GLEnums::GetStringEnum(face) << ", "
                  << GLEnums::GetStringEnum(fail) << ", "
                  << GLEnums::GetStringEnum(zfail) << ", "
                  << GLEnums::GetStringEnum(zpass) << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilOpSeparateFn != nullptr);
   g_driver_gl.debug_fn.glStencilOpSeparateFn(face, fail, zfail, zpass);
 }
 
 static void GL_BINDING_CALL
 Debug_glStencilStrokePathInstancedNV(GLsizei numPaths,
                                      GLenum pathNameType,
                                      const void* paths,
                                      GLuint pathBase,
                                      GLint ref,
                                      GLuint mask,
                                      GLenum transformType,
                                      const GLfloat* transformValues) {
   GL_SERVICE_LOG(
       "glStencilStrokePathInstancedNV"
       << "(" << numPaths << ", " << GLEnums::GetStringEnum(pathNameType) << ", "
       << static_cast<const void*>(paths) << ", " << pathBase << ", " << ref
       << ", " << mask << ", " << GLEnums::GetStringEnum(transformType) << ", "
       << static_cast<const void*>(transformValues) << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilStrokePathInstancedNVFn != nullptr);
   g_driver_gl.debug_fn.glStencilStrokePathInstancedNVFn(
       numPaths, pathNameType, paths, pathBase, ref, mask, transformType,
       transformValues);
 }
 
 static void GL_BINDING_CALL Debug_glStencilStrokePathNV(GLuint path,
                                                         GLint reference,
                                                         GLuint mask) {
   GL_SERVICE_LOG("glStencilStrokePathNV"
                  << "(" << path << ", " << reference << ", " << mask << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilStrokePathNVFn != nullptr);
   g_driver_gl.debug_fn.glStencilStrokePathNVFn(path, reference, mask);
 }
 
 static void GL_BINDING_CALL
 Debug_glStencilThenCoverFillPathInstancedNV(GLsizei numPaths,
                                             GLenum pathNameType,
                                             const void* paths,
                                             GLuint pathBase,
                                             GLenum fillMode,
                                             GLuint mask,
                                             GLenum coverMode,
                                             GLenum transformType,
                                             const GLfloat* transformValues) {
   GL_SERVICE_LOG("glStencilThenCoverFillPathInstancedNV"
                  << "(" << numPaths << ", "
                  << GLEnums::GetStringEnum(pathNameType) << ", "
                  << static_cast<const void*>(paths) << ", " << pathBase << ", "
                  << GLEnums::GetStringEnum(fillMode) << ", " << mask << ", "
                  << GLEnums::GetStringEnum(coverMode) << ", "
                  << GLEnums::GetStringEnum(transformType) << ", "
                  << static_cast<const void*>(transformValues) << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilThenCoverFillPathInstancedNVFn !=
+         nullptr);
   g_driver_gl.debug_fn.glStencilThenCoverFillPathInstancedNVFn(
       numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode,
       transformType, transformValues);
 }
 
 static void GL_BINDING_CALL
 Debug_glStencilThenCoverFillPathNV(GLuint path,
                                    GLenum fillMode,
                                    GLuint mask,
                                    GLenum coverMode) {
   GL_SERVICE_LOG("glStencilThenCoverFillPathNV"
                  << "(" << path << ", " << GLEnums::GetStringEnum(fillMode)
                  << ", " << mask << ", " << GLEnums::GetStringEnum(coverMode)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilThenCoverFillPathNVFn != nullptr);
   g_driver_gl.debug_fn.glStencilThenCoverFillPathNVFn(path, fillMode, mask,
                                                       coverMode);
 }
 
 static void GL_BINDING_CALL
 Debug_glStencilThenCoverStrokePathInstancedNV(GLsizei numPaths,
                                               GLenum pathNameType,
                                               const void* paths,
                                               GLuint pathBase,
                                               GLint ref,
                                               GLuint mask,
                                               GLenum coverMode,
                                               GLenum transformType,
                                               const GLfloat* transformValues) {
   GL_SERVICE_LOG(
       "glStencilThenCoverStrokePathInstancedNV"
       << "(" << numPaths << ", " << GLEnums::GetStringEnum(pathNameType) << ", "
       << static_cast<const void*>(paths) << ", " << pathBase << ", " << ref
       << ", " << mask << ", " << GLEnums::GetStringEnum(coverMode) << ", "
       << GLEnums::GetStringEnum(transformType) << ", "
       << static_cast<const void*>(transformValues) << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilThenCoverStrokePathInstancedNVFn !=
+         nullptr);
   g_driver_gl.debug_fn.glStencilThenCoverStrokePathInstancedNVFn(
       numPaths, pathNameType, paths, pathBase, ref, mask, coverMode,
       transformType, transformValues);
 }
 
 static void GL_BINDING_CALL
 Debug_glStencilThenCoverStrokePathNV(GLuint path,
                                      GLint reference,
                                      GLuint mask,
                                      GLenum coverMode) {
   GL_SERVICE_LOG("glStencilThenCoverStrokePathNV"
                  << "(" << path << ", " << reference << ", " << mask << ", "
                  << GLEnums::GetStringEnum(coverMode) << ")");
+  DCHECK(g_driver_gl.debug_fn.glStencilThenCoverStrokePathNVFn != nullptr);
   g_driver_gl.debug_fn.glStencilThenCoverStrokePathNVFn(path, reference, mask,
                                                         coverMode);
 }
 
 static GLboolean GL_BINDING_CALL Debug_glTestFenceAPPLE(GLuint fence) {
   GL_SERVICE_LOG("glTestFenceAPPLE"
                  << "(" << fence << ")");
+  DCHECK(g_driver_gl.debug_fn.glTestFenceAPPLEFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glTestFenceAPPLEFn(fence);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static GLboolean GL_BINDING_CALL Debug_glTestFenceNV(GLuint fence) {
   GL_SERVICE_LOG("glTestFenceNV"
                  << "(" << fence << ")");
+  DCHECK(g_driver_gl.debug_fn.glTestFenceNVFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glTestFenceNVFn(fence);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glTexImage2D(GLenum target,
                                                GLint level,
                                                GLint internalformat,
                                                GLsizei width,
                                                GLsizei height,
                                                GLint border,
                                                GLenum format,
                                                GLenum type,
                                                const void* pixels) {
   GL_SERVICE_LOG("glTexImage2D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << internalformat << ", " << width << ", " << height
                  << ", " << border << ", " << GLEnums::GetStringEnum(format)
                  << ", " << GLEnums::GetStringEnum(type) << ", "
                  << static_cast<const void*>(pixels) << ")");
+  DCHECK(g_driver_gl.debug_fn.glTexImage2DFn != nullptr);
   g_driver_gl.debug_fn.glTexImage2DFn(target, level, internalformat, width,
                                       height, border, format, type, pixels);
 }
 
 static void GL_BINDING_CALL Debug_glTexImage3D(GLenum target,
                                                GLint level,
                                                GLint internalformat,
                                                GLsizei width,
                                                GLsizei height,
                                                GLsizei depth,
                                                GLint border,
                                                GLenum format,
                                                GLenum type,
                                                const void* pixels) {
   GL_SERVICE_LOG("glTexImage3D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << internalformat << ", " << width << ", " << height
                  << ", " << depth << ", " << border << ", "
                  << GLEnums::GetStringEnum(format) << ", "
                  << GLEnums::GetStringEnum(type) << ", "
                  << static_cast<const void*>(pixels) << ")");
+  DCHECK(g_driver_gl.debug_fn.glTexImage3DFn != nullptr);
   g_driver_gl.debug_fn.glTexImage3DFn(target, level, internalformat, width,
                                       height, depth, border, format, type,
                                       pixels);
 }
 
 static void GL_BINDING_CALL Debug_glTexParameterf(GLenum target,
                                                   GLenum pname,
                                                   GLfloat param) {
   GL_SERVICE_LOG("glTexParameterf"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", " << param << ")");
+  DCHECK(g_driver_gl.debug_fn.glTexParameterfFn != nullptr);
   g_driver_gl.debug_fn.glTexParameterfFn(target, pname, param);
 }
 
 static void GL_BINDING_CALL Debug_glTexParameterfv(GLenum target,
                                                    GLenum pname,
                                                    const GLfloat* params) {
   GL_SERVICE_LOG("glTexParameterfv"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glTexParameterfvFn != nullptr);
   g_driver_gl.debug_fn.glTexParameterfvFn(target, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glTexParameteri(GLenum target,
                                                   GLenum pname,
                                                   GLint param) {
   GL_SERVICE_LOG("glTexParameteri"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", " << param << ")");
+  DCHECK(g_driver_gl.debug_fn.glTexParameteriFn != nullptr);
   g_driver_gl.debug_fn.glTexParameteriFn(target, pname, param);
 }
 
 static void GL_BINDING_CALL Debug_glTexParameteriv(GLenum target,
                                                    GLenum pname,
                                                    const GLint* params) {
   GL_SERVICE_LOG("glTexParameteriv"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
                  << GLEnums::GetStringEnum(pname) << ", "
                  << static_cast<const void*>(params) << ")");
+  DCHECK(g_driver_gl.debug_fn.glTexParameterivFn != nullptr);
   g_driver_gl.debug_fn.glTexParameterivFn(target, pname, params);
 }
 
 static void GL_BINDING_CALL Debug_glTexStorage2DEXT(GLenum target,
                                                     GLsizei levels,
                                                     GLenum internalformat,
                                                     GLsizei width,
                                                     GLsizei height) {
   GL_SERVICE_LOG("glTexStorage2DEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << levels
                  << ", " << GLEnums::GetStringEnum(internalformat) << ", "
                  << width << ", " << height << ")");
+  DCHECK(g_driver_gl.debug_fn.glTexStorage2DEXTFn != nullptr);
   g_driver_gl.debug_fn.glTexStorage2DEXTFn(target, levels, internalformat,
                                            width, height);
 }
 
 static void GL_BINDING_CALL Debug_glTexStorage3D(GLenum target,
                                                  GLsizei levels,
                                                  GLenum internalformat,
                                                  GLsizei width,
                                                  GLsizei height,
                                                  GLsizei depth) {
   GL_SERVICE_LOG("glTexStorage3D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << levels
                  << ", " << GLEnums::GetStringEnum(internalformat) << ", "
                  << width << ", " << height << ", " << depth << ")");
+  DCHECK(g_driver_gl.debug_fn.glTexStorage3DFn != nullptr);
   g_driver_gl.debug_fn.glTexStorage3DFn(target, levels, internalformat, width,
                                         height, depth);
 }
 
 static void GL_BINDING_CALL Debug_glTexSubImage2D(GLenum target,
                                                   GLint level,
                                                   GLint xoffset,
                                                   GLint yoffset,
                                                   GLsizei width,
                                                   GLsizei height,
                                                   GLenum format,
                                                   GLenum type,
                                                   const void* pixels) {
   GL_SERVICE_LOG("glTexSubImage2D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << xoffset << ", " << yoffset << ", " << width << ", "
                  << height << ", " << GLEnums::GetStringEnum(format) << ", "
                  << GLEnums::GetStringEnum(type) << ", "
                  << static_cast<const void*>(pixels) << ")");
+  DCHECK(g_driver_gl.debug_fn.glTexSubImage2DFn != nullptr);
   g_driver_gl.debug_fn.glTexSubImage2DFn(target, level, xoffset, yoffset, width,
                                          height, format, type, pixels);
 }
 
 static void GL_BINDING_CALL Debug_glTexSubImage3D(GLenum target,
                                                   GLint level,
                                                   GLint xoffset,
                                                   GLint yoffset,
                                                   GLint zoffset,
                                                   GLsizei width,
                                                   GLsizei height,
                                                   GLsizei depth,
                                                   GLenum format,
                                                   GLenum type,
                                                   const void* pixels) {
   GL_SERVICE_LOG("glTexSubImage3D"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << level
                  << ", " << xoffset << ", " << yoffset << ", " << zoffset
                  << ", " << width << ", " << height << ", " << depth << ", "
                  << GLEnums::GetStringEnum(format) << ", "
                  << GLEnums::GetStringEnum(type) << ", "
                  << static_cast<const void*>(pixels) << ")");
+  DCHECK(g_driver_gl.debug_fn.glTexSubImage3DFn != nullptr);
   g_driver_gl.debug_fn.glTexSubImage3DFn(target, level, xoffset, yoffset,
                                          zoffset, width, height, depth, format,
                                          type, pixels);
 }
 
 static void GL_BINDING_CALL
 Debug_glTransformFeedbackVaryings(GLuint program,
                                   GLsizei count,
                                   const char* const* varyings,
                                   GLenum bufferMode) {
   GL_SERVICE_LOG("glTransformFeedbackVaryings"
                  << "(" << program << ", " << count << ", "
                  << static_cast<const void*>(varyings) << ", "
                  << GLEnums::GetStringEnum(bufferMode) << ")");
+  DCHECK(g_driver_gl.debug_fn.glTransformFeedbackVaryingsFn != nullptr);
   g_driver_gl.debug_fn.glTransformFeedbackVaryingsFn(program, count, varyings,
                                                      bufferMode);
 }
 
 static void GL_BINDING_CALL Debug_glUniform1f(GLint location, GLfloat x) {
   GL_SERVICE_LOG("glUniform1f"
                  << "(" << location << ", " << x << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform1fFn != nullptr);
   g_driver_gl.debug_fn.glUniform1fFn(location, x);
 }
 
 static void GL_BINDING_CALL Debug_glUniform1fv(GLint location,
                                                GLsizei count,
                                                const GLfloat* v) {
   GL_SERVICE_LOG("glUniform1fv"
                  << "(" << location << ", " << count << ", "
                  << static_cast<const void*>(v) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform1fvFn != nullptr);
   g_driver_gl.debug_fn.glUniform1fvFn(location, count, v);
 }
 
 static void GL_BINDING_CALL Debug_glUniform1i(GLint location, GLint x) {
   GL_SERVICE_LOG("glUniform1i"
                  << "(" << location << ", " << x << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform1iFn != nullptr);
   g_driver_gl.debug_fn.glUniform1iFn(location, x);
 }
 
 static void GL_BINDING_CALL Debug_glUniform1iv(GLint location,
                                                GLsizei count,
                                                const GLint* v) {
   GL_SERVICE_LOG("glUniform1iv"
                  << "(" << location << ", " << count << ", "
                  << static_cast<const void*>(v) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform1ivFn != nullptr);
   g_driver_gl.debug_fn.glUniform1ivFn(location, count, v);
 }
 
 static void GL_BINDING_CALL Debug_glUniform1ui(GLint location, GLuint v0) {
   GL_SERVICE_LOG("glUniform1ui"
                  << "(" << location << ", " << v0 << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform1uiFn != nullptr);
   g_driver_gl.debug_fn.glUniform1uiFn(location, v0);
 }
 
 static void GL_BINDING_CALL Debug_glUniform1uiv(GLint location,
                                                 GLsizei count,
                                                 const GLuint* v) {
   GL_SERVICE_LOG("glUniform1uiv"
                  << "(" << location << ", " << count << ", "
                  << static_cast<const void*>(v) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform1uivFn != nullptr);
   g_driver_gl.debug_fn.glUniform1uivFn(location, count, v);
 }
 
 static void GL_BINDING_CALL Debug_glUniform2f(GLint location,
                                               GLfloat x,
                                               GLfloat y) {
   GL_SERVICE_LOG("glUniform2f"
                  << "(" << location << ", " << x << ", " << y << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform2fFn != nullptr);
   g_driver_gl.debug_fn.glUniform2fFn(location, x, y);
 }
 
 static void GL_BINDING_CALL Debug_glUniform2fv(GLint location,
                                                GLsizei count,
                                                const GLfloat* v) {
   GL_SERVICE_LOG("glUniform2fv"
                  << "(" << location << ", " << count << ", "
                  << static_cast<const void*>(v) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform2fvFn != nullptr);
   g_driver_gl.debug_fn.glUniform2fvFn(location, count, v);
 }
 
 static void GL_BINDING_CALL Debug_glUniform2i(GLint location,
                                               GLint x,
                                               GLint y) {
   GL_SERVICE_LOG("glUniform2i"
                  << "(" << location << ", " << x << ", " << y << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform2iFn != nullptr);
   g_driver_gl.debug_fn.glUniform2iFn(location, x, y);
 }
 
 static void GL_BINDING_CALL Debug_glUniform2iv(GLint location,
                                                GLsizei count,
                                                const GLint* v) {
   GL_SERVICE_LOG("glUniform2iv"
                  << "(" << location << ", " << count << ", "
                  << static_cast<const void*>(v) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform2ivFn != nullptr);
   g_driver_gl.debug_fn.glUniform2ivFn(location, count, v);
 }
 
 static void GL_BINDING_CALL Debug_glUniform2ui(GLint location,
                                                GLuint v0,
                                                GLuint v1) {
   GL_SERVICE_LOG("glUniform2ui"
                  << "(" << location << ", " << v0 << ", " << v1 << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform2uiFn != nullptr);
   g_driver_gl.debug_fn.glUniform2uiFn(location, v0, v1);
 }
 
 static void GL_BINDING_CALL Debug_glUniform2uiv(GLint location,
                                                 GLsizei count,
                                                 const GLuint* v) {
   GL_SERVICE_LOG("glUniform2uiv"
                  << "(" << location << ", " << count << ", "
                  << static_cast<const void*>(v) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform2uivFn != nullptr);
   g_driver_gl.debug_fn.glUniform2uivFn(location, count, v);
 }
 
 static void GL_BINDING_CALL Debug_glUniform3f(GLint location,
                                               GLfloat x,
                                               GLfloat y,
                                               GLfloat z) {
   GL_SERVICE_LOG("glUniform3f"
                  << "(" << location << ", " << x << ", " << y << ", " << z
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform3fFn != nullptr);
   g_driver_gl.debug_fn.glUniform3fFn(location, x, y, z);
 }
 
 static void GL_BINDING_CALL Debug_glUniform3fv(GLint location,
                                                GLsizei count,
                                                const GLfloat* v) {
   GL_SERVICE_LOG("glUniform3fv"
                  << "(" << location << ", " << count << ", "
                  << static_cast<const void*>(v) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform3fvFn != nullptr);
   g_driver_gl.debug_fn.glUniform3fvFn(location, count, v);
 }
 
 static void GL_BINDING_CALL Debug_glUniform3i(GLint location,
                                               GLint x,
                                               GLint y,
                                               GLint z) {
   GL_SERVICE_LOG("glUniform3i"
                  << "(" << location << ", " << x << ", " << y << ", " << z
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform3iFn != nullptr);
   g_driver_gl.debug_fn.glUniform3iFn(location, x, y, z);
 }
 
 static void GL_BINDING_CALL Debug_glUniform3iv(GLint location,
                                                GLsizei count,
                                                const GLint* v) {
   GL_SERVICE_LOG("glUniform3iv"
                  << "(" << location << ", " << count << ", "
                  << static_cast<const void*>(v) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform3ivFn != nullptr);
   g_driver_gl.debug_fn.glUniform3ivFn(location, count, v);
 }
 
 static void GL_BINDING_CALL Debug_glUniform3ui(GLint location,
                                                GLuint v0,
                                                GLuint v1,
                                                GLuint v2) {
   GL_SERVICE_LOG("glUniform3ui"
                  << "(" << location << ", " << v0 << ", " << v1 << ", " << v2
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform3uiFn != nullptr);
   g_driver_gl.debug_fn.glUniform3uiFn(location, v0, v1, v2);
 }
 
 static void GL_BINDING_CALL Debug_glUniform3uiv(GLint location,
                                                 GLsizei count,
                                                 const GLuint* v) {
   GL_SERVICE_LOG("glUniform3uiv"
                  << "(" << location << ", " << count << ", "
                  << static_cast<const void*>(v) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform3uivFn != nullptr);
   g_driver_gl.debug_fn.glUniform3uivFn(location, count, v);
 }
 
 static void GL_BINDING_CALL
 Debug_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
   GL_SERVICE_LOG("glUniform4f"
                  << "(" << location << ", " << x << ", " << y << ", " << z
                  << ", " << w << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform4fFn != nullptr);
   g_driver_gl.debug_fn.glUniform4fFn(location, x, y, z, w);
 }
 
 static void GL_BINDING_CALL Debug_glUniform4fv(GLint location,
                                                GLsizei count,
                                                const GLfloat* v) {
   GL_SERVICE_LOG("glUniform4fv"
                  << "(" << location << ", " << count << ", "
                  << static_cast<const void*>(v) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform4fvFn != nullptr);
   g_driver_gl.debug_fn.glUniform4fvFn(location, count, v);
 }
 
 static void GL_BINDING_CALL
 Debug_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w) {
   GL_SERVICE_LOG("glUniform4i"
                  << "(" << location << ", " << x << ", " << y << ", " << z
                  << ", " << w << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform4iFn != nullptr);
   g_driver_gl.debug_fn.glUniform4iFn(location, x, y, z, w);
 }
 
 static void GL_BINDING_CALL Debug_glUniform4iv(GLint location,
                                                GLsizei count,
                                                const GLint* v) {
   GL_SERVICE_LOG("glUniform4iv"
                  << "(" << location << ", " << count << ", "
                  << static_cast<const void*>(v) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform4ivFn != nullptr);
   g_driver_gl.debug_fn.glUniform4ivFn(location, count, v);
 }
 
 static void GL_BINDING_CALL
 Debug_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
   GL_SERVICE_LOG("glUniform4ui"
                  << "(" << location << ", " << v0 << ", " << v1 << ", " << v2
                  << ", " << v3 << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform4uiFn != nullptr);
   g_driver_gl.debug_fn.glUniform4uiFn(location, v0, v1, v2, v3);
 }
 
 static void GL_BINDING_CALL Debug_glUniform4uiv(GLint location,
                                                 GLsizei count,
                                                 const GLuint* v) {
   GL_SERVICE_LOG("glUniform4uiv"
                  << "(" << location << ", " << count << ", "
                  << static_cast<const void*>(v) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniform4uivFn != nullptr);
   g_driver_gl.debug_fn.glUniform4uivFn(location, count, v);
 }
 
 static void GL_BINDING_CALL
 Debug_glUniformBlockBinding(GLuint program,
                             GLuint uniformBlockIndex,
                             GLuint uniformBlockBinding) {
   GL_SERVICE_LOG("glUniformBlockBinding"
                  << "(" << program << ", " << uniformBlockIndex << ", "
                  << uniformBlockBinding << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniformBlockBindingFn != nullptr);
   g_driver_gl.debug_fn.glUniformBlockBindingFn(program, uniformBlockIndex,
                                                uniformBlockBinding);
 }
 
 static void GL_BINDING_CALL Debug_glUniformMatrix2fv(GLint location,
                                                      GLsizei count,
                                                      GLboolean transpose,
                                                      const GLfloat* value) {
   GL_SERVICE_LOG("glUniformMatrix2fv"
                  << "(" << location << ", " << count << ", "
                  << GLEnums::GetStringBool(transpose) << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniformMatrix2fvFn != nullptr);
   g_driver_gl.debug_fn.glUniformMatrix2fvFn(location, count, transpose, value);
 }
 
 static void GL_BINDING_CALL Debug_glUniformMatrix2x3fv(GLint location,
                                                        GLsizei count,
                                                        GLboolean transpose,
                                                        const GLfloat* value) {
   GL_SERVICE_LOG("glUniformMatrix2x3fv"
                  << "(" << location << ", " << count << ", "
                  << GLEnums::GetStringBool(transpose) << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniformMatrix2x3fvFn != nullptr);
   g_driver_gl.debug_fn.glUniformMatrix2x3fvFn(location, count, transpose,
                                               value);
 }
 
 static void GL_BINDING_CALL Debug_glUniformMatrix2x4fv(GLint location,
                                                        GLsizei count,
                                                        GLboolean transpose,
                                                        const GLfloat* value) {
   GL_SERVICE_LOG("glUniformMatrix2x4fv"
                  << "(" << location << ", " << count << ", "
                  << GLEnums::GetStringBool(transpose) << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniformMatrix2x4fvFn != nullptr);
   g_driver_gl.debug_fn.glUniformMatrix2x4fvFn(location, count, transpose,
                                               value);
 }
 
 static void GL_BINDING_CALL Debug_glUniformMatrix3fv(GLint location,
                                                      GLsizei count,
                                                      GLboolean transpose,
                                                      const GLfloat* value) {
   GL_SERVICE_LOG("glUniformMatrix3fv"
                  << "(" << location << ", " << count << ", "
                  << GLEnums::GetStringBool(transpose) << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniformMatrix3fvFn != nullptr);
   g_driver_gl.debug_fn.glUniformMatrix3fvFn(location, count, transpose, value);
 }
 
 static void GL_BINDING_CALL Debug_glUniformMatrix3x2fv(GLint location,
                                                        GLsizei count,
                                                        GLboolean transpose,
                                                        const GLfloat* value) {
   GL_SERVICE_LOG("glUniformMatrix3x2fv"
                  << "(" << location << ", " << count << ", "
                  << GLEnums::GetStringBool(transpose) << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniformMatrix3x2fvFn != nullptr);
   g_driver_gl.debug_fn.glUniformMatrix3x2fvFn(location, count, transpose,
                                               value);
 }
 
 static void GL_BINDING_CALL Debug_glUniformMatrix3x4fv(GLint location,
                                                        GLsizei count,
                                                        GLboolean transpose,
                                                        const GLfloat* value) {
   GL_SERVICE_LOG("glUniformMatrix3x4fv"
                  << "(" << location << ", " << count << ", "
                  << GLEnums::GetStringBool(transpose) << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniformMatrix3x4fvFn != nullptr);
   g_driver_gl.debug_fn.glUniformMatrix3x4fvFn(location, count, transpose,
                                               value);
 }
 
 static void GL_BINDING_CALL Debug_glUniformMatrix4fv(GLint location,
                                                      GLsizei count,
                                                      GLboolean transpose,
                                                      const GLfloat* value) {
   GL_SERVICE_LOG("glUniformMatrix4fv"
                  << "(" << location << ", " << count << ", "
                  << GLEnums::GetStringBool(transpose) << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniformMatrix4fvFn != nullptr);
   g_driver_gl.debug_fn.glUniformMatrix4fvFn(location, count, transpose, value);
 }
 
 static void GL_BINDING_CALL Debug_glUniformMatrix4x2fv(GLint location,
                                                        GLsizei count,
                                                        GLboolean transpose,
                                                        const GLfloat* value) {
   GL_SERVICE_LOG("glUniformMatrix4x2fv"
                  << "(" << location << ", " << count << ", "
                  << GLEnums::GetStringBool(transpose) << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniformMatrix4x2fvFn != nullptr);
   g_driver_gl.debug_fn.glUniformMatrix4x2fvFn(location, count, transpose,
                                               value);
 }
 
 static void GL_BINDING_CALL Debug_glUniformMatrix4x3fv(GLint location,
                                                        GLsizei count,
                                                        GLboolean transpose,
                                                        const GLfloat* value) {
   GL_SERVICE_LOG("glUniformMatrix4x3fv"
                  << "(" << location << ", " << count << ", "
                  << GLEnums::GetStringBool(transpose) << ", "
                  << static_cast<const void*>(value) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUniformMatrix4x3fvFn != nullptr);
   g_driver_gl.debug_fn.glUniformMatrix4x3fvFn(location, count, transpose,
                                               value);
 }
 
 static GLboolean GL_BINDING_CALL Debug_glUnmapBuffer(GLenum target) {
   GL_SERVICE_LOG("glUnmapBuffer"
                  << "(" << GLEnums::GetStringEnum(target) << ")");
+  DCHECK(g_driver_gl.debug_fn.glUnmapBufferFn != nullptr);
   GLboolean result = g_driver_gl.debug_fn.glUnmapBufferFn(target);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 
 static void GL_BINDING_CALL Debug_glUseProgram(GLuint program) {
   GL_SERVICE_LOG("glUseProgram"
                  << "(" << program << ")");
+  DCHECK(g_driver_gl.debug_fn.glUseProgramFn != nullptr);
   g_driver_gl.debug_fn.glUseProgramFn(program);
 }
 
 static void GL_BINDING_CALL Debug_glValidateProgram(GLuint program) {
   GL_SERVICE_LOG("glValidateProgram"
                  << "(" << program << ")");
+  DCHECK(g_driver_gl.debug_fn.glValidateProgramFn != nullptr);
   g_driver_gl.debug_fn.glValidateProgramFn(program);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttrib1f(GLuint indx, GLfloat x) {
   GL_SERVICE_LOG("glVertexAttrib1f"
                  << "(" << indx << ", " << x << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttrib1fFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttrib1fFn(indx, x);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttrib1fv(GLuint indx,
                                                     const GLfloat* values) {
   GL_SERVICE_LOG("glVertexAttrib1fv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttrib1fvFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttrib1fvFn(indx, values);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttrib2f(GLuint indx,
                                                    GLfloat x,
                                                    GLfloat y) {
   GL_SERVICE_LOG("glVertexAttrib2f"
                  << "(" << indx << ", " << x << ", " << y << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttrib2fFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttrib2fFn(indx, x, y);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttrib2fv(GLuint indx,
                                                     const GLfloat* values) {
   GL_SERVICE_LOG("glVertexAttrib2fv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttrib2fvFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttrib2fvFn(indx, values);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttrib3f(GLuint indx,
                                                    GLfloat x,
                                                    GLfloat y,
                                                    GLfloat z) {
   GL_SERVICE_LOG("glVertexAttrib3f"
                  << "(" << indx << ", " << x << ", " << y << ", " << z << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttrib3fFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttrib3fFn(indx, x, y, z);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttrib3fv(GLuint indx,
                                                     const GLfloat* values) {
   GL_SERVICE_LOG("glVertexAttrib3fv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttrib3fvFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttrib3fvFn(indx, values);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttrib4f(GLuint indx,
                                                    GLfloat x,
                                                    GLfloat y,
                                                    GLfloat z,
                                                    GLfloat w) {
   GL_SERVICE_LOG("glVertexAttrib4f"
                  << "(" << indx << ", " << x << ", " << y << ", " << z << ", "
                  << w << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttrib4fFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttrib4fFn(indx, x, y, z, w);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttrib4fv(GLuint indx,
                                                     const GLfloat* values) {
   GL_SERVICE_LOG("glVertexAttrib4fv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttrib4fvFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttrib4fvFn(indx, values);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttribDivisorANGLE(GLuint index,
                                                              GLuint divisor) {
   GL_SERVICE_LOG("glVertexAttribDivisorANGLE"
                  << "(" << index << ", " << divisor << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttribDivisorANGLEFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttribDivisorANGLEFn(index, divisor);
 }
 
 static void GL_BINDING_CALL
 Debug_glVertexAttribI4i(GLuint indx, GLint x, GLint y, GLint z, GLint w) {
   GL_SERVICE_LOG("glVertexAttribI4i"
                  << "(" << indx << ", " << x << ", " << y << ", " << z << ", "
                  << w << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttribI4iFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttribI4iFn(indx, x, y, z, w);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttribI4iv(GLuint indx,
                                                      const GLint* values) {
   GL_SERVICE_LOG("glVertexAttribI4iv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttribI4ivFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttribI4ivFn(indx, values);
 }
 
 static void GL_BINDING_CALL
 Debug_glVertexAttribI4ui(GLuint indx, GLuint x, GLuint y, GLuint z, GLuint w) {
   GL_SERVICE_LOG("glVertexAttribI4ui"
                  << "(" << indx << ", " << x << ", " << y << ", " << z << ", "
                  << w << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttribI4uiFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttribI4uiFn(indx, x, y, z, w);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttribI4uiv(GLuint indx,
                                                       const GLuint* values) {
   GL_SERVICE_LOG("glVertexAttribI4uiv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttribI4uivFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttribI4uivFn(indx, values);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttribIPointer(GLuint indx,
                                                          GLint size,
                                                          GLenum type,
                                                          GLsizei stride,
                                                          const void* ptr) {
   GL_SERVICE_LOG("glVertexAttribIPointer"
                  << "(" << indx << ", " << size << ", "
                  << GLEnums::GetStringEnum(type) << ", " << stride << ", "
                  << static_cast<const void*>(ptr) << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttribIPointerFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttribIPointerFn(indx, size, type, stride, ptr);
 }
 
 static void GL_BINDING_CALL Debug_glVertexAttribPointer(GLuint indx,
                                                         GLint size,
                                                         GLenum type,
                                                         GLboolean normalized,
                                                         GLsizei stride,
                                                         const void* ptr) {
   GL_SERVICE_LOG("glVertexAttribPointer"
                  << "(" << indx << ", " << size << ", "
                  << GLEnums::GetStringEnum(type) << ", "
                  << GLEnums::GetStringBool(normalized) << ", " << stride << ", "
                  << static_cast<const void*>(ptr) << ")");
+  DCHECK(g_driver_gl.debug_fn.glVertexAttribPointerFn != nullptr);
   g_driver_gl.debug_fn.glVertexAttribPointerFn(indx, size, type, normalized,
                                                stride, ptr);
 }
 
 static void GL_BINDING_CALL Debug_glViewport(GLint x,
                                              GLint y,
                                              GLsizei width,
                                              GLsizei height) {
   GL_SERVICE_LOG("glViewport"
                  << "(" << x << ", " << y << ", " << width << ", " << height
                  << ")");
+  DCHECK(g_driver_gl.debug_fn.glViewportFn != nullptr);
   g_driver_gl.debug_fn.glViewportFn(x, y, width, height);
 }
 
 static GLenum GL_BINDING_CALL Debug_glWaitSync(GLsync sync,
                                                GLbitfield flags,
                                                GLuint64 timeout) {
   GL_SERVICE_LOG("glWaitSync"
                  << "(" << sync << ", " << flags << ", " << timeout << ")");
+  DCHECK(g_driver_gl.debug_fn.glWaitSyncFn != nullptr);
   GLenum result = g_driver_gl.debug_fn.glWaitSyncFn(sync, flags, timeout);
   GL_SERVICE_LOG("GL_RESULT: " << result);
   return result;
 }
 }  // extern "C"
 
 void DriverGL::InitializeDebugBindings() {
   if (!debug_fn.glActiveTextureFn) {
     debug_fn.glActiveTextureFn = fn.glActiveTextureFn;
     fn.glActiveTextureFn = Debug_glActiveTexture;
@@ skipping 7961 matching lines @@
 
 GLenum NoContextGLApi::glWaitSyncFn(GLsync sync,
                                     GLbitfield flags,
                                     GLuint64 timeout) {
   NOTREACHED() << "Trying to call glWaitSync() without current GL context";
   LOG(ERROR) << "Trying to call glWaitSync() without current GL context";
   return static_cast<GLenum>(0);
 }
 
 }  // namespace gfx