Do not dereference NULL even if such pointer is given by test code.

- Avoid printing raw char* ptrs, always use getStringStr()
- Avoid printing pointers to prevent similar issues in the with other
  types.

Bug: 19679876
Change-Id: I52fe1505026f0570f035fc18dcc8385b77f203f2

diff --git a/framework/opengl/gluCallLogWrapper.inl b/framework/opengl/gluCallLogWrapper.inl
index 8f94738..0367474 100644 (file)
--- a/framework/opengl/gluCallLogWrapper.inl
+++ b/framework/opengl/gluCallLogWrapper.inl
@@ -84,14 +84,14 @@ void CallLogWrapper::glBindBufferRange (glw::GLenum target, glw::GLuint index, g
 void CallLogWrapper::glBindBuffersBase (glw::GLenum target, glw::GLuint first, glw::GLsizei count, const glw::GLuint *buffers)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glBindBuffersBase(" << toHex(target) << ", " << first << ", " << count << ", " << buffers << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glBindBuffersBase(" << toHex(target) << ", " << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ");" << TestLog::EndMessage;
        m_gl.bindBuffersBase(target, first, count, buffers);
 }
 
 void CallLogWrapper::glBindBuffersRange (glw::GLenum target, glw::GLuint first, glw::GLsizei count, const glw::GLuint *buffers, const glw::GLintptr *offsets, const glw::GLsizeiptr *sizes)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glBindBuffersRange(" << toHex(target) << ", " << first << ", " << count << ", " << buffers << ", " << offsets << ", " << sizes << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glBindBuffersRange(" << toHex(target) << ", " << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(offsets))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(sizes))) << ");" << TestLog::EndMessage;
        m_gl.bindBuffersRange(target, first, count, buffers, offsets, sizes);
 }
 
@@ -126,7 +126,7 @@ void CallLogWrapper::glBindImageTexture (glw::GLuint unit, glw::GLuint texture,
 void CallLogWrapper::glBindImageTextures (glw::GLuint first, glw::GLsizei count, const glw::GLuint *textures)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glBindImageTextures(" << first << ", " << count << ", " << textures << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glBindImageTextures(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(textures))) << ");" << TestLog::EndMessage;
        m_gl.bindImageTextures(first, count, textures);
 }
 
@@ -154,7 +154,7 @@ void CallLogWrapper::glBindSampler (glw::GLuint unit, glw::GLuint sampler)
 void CallLogWrapper::glBindSamplers (glw::GLuint first, glw::GLsizei count, const glw::GLuint *samplers)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glBindSamplers(" << first << ", " << count << ", " << samplers << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glBindSamplers(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(samplers))) << ");" << TestLog::EndMessage;
        m_gl.bindSamplers(first, count, samplers);
 }
 
@@ -175,7 +175,7 @@ void CallLogWrapper::glBindTextureUnit (glw::GLuint unit, glw::GLuint texture)
 void CallLogWrapper::glBindTextures (glw::GLuint first, glw::GLsizei count, const glw::GLuint *textures)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glBindTextures(" << first << ", " << count << ", " << textures << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glBindTextures(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(textures))) << ");" << TestLog::EndMessage;
        m_gl.bindTextures(first, count, textures);
 }
 
@@ -203,7 +203,7 @@ void CallLogWrapper::glBindVertexBuffer (glw::GLuint bindingindex, glw::GLuint b
 void CallLogWrapper::glBindVertexBuffers (glw::GLuint first, glw::GLsizei count, const glw::GLuint *buffers, const glw::GLintptr *offsets, const glw::GLsizei *strides)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glBindVertexBuffers(" << first << ", " << count << ", " << buffers << ", " << offsets << ", " << strides << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glBindVertexBuffers(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(offsets))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(strides))) << ");" << TestLog::EndMessage;
        m_gl.bindVertexBuffers(first, count, buffers, offsets, strides);
 }
 
@@ -370,21 +370,21 @@ void CallLogWrapper::glClearBufferfi (glw::GLenum buffer, glw::GLint drawbuffer,
 void CallLogWrapper::glClearBufferfv (glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLfloat *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glClearBufferfv(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glClearBufferfv(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.clearBufferfv(buffer, drawbuffer, value);
 }
 
 void CallLogWrapper::glClearBufferiv (glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLint *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glClearBufferiv(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glClearBufferiv(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.clearBufferiv(buffer, drawbuffer, value);
 }
 
 void CallLogWrapper::glClearBufferuiv (glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLuint *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glClearBufferuiv(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glClearBufferuiv(" << getBufferStr(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.clearBufferuiv(buffer, drawbuffer, value);
 }
 
@@ -433,21 +433,21 @@ void CallLogWrapper::glClearNamedFramebufferfi (glw::GLuint framebuffer, glw::GL
 void CallLogWrapper::glClearNamedFramebufferfv (glw::GLuint framebuffer, glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLfloat *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glClearNamedFramebufferfv(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glClearNamedFramebufferfv(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.clearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
 }
 
 void CallLogWrapper::glClearNamedFramebufferiv (glw::GLuint framebuffer, glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLint *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glClearNamedFramebufferiv(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glClearNamedFramebufferiv(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.clearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
 }
 
 void CallLogWrapper::glClearNamedFramebufferuiv (glw::GLuint framebuffer, glw::GLenum buffer, glw::GLint drawbuffer, const glw::GLuint *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glClearNamedFramebufferuiv(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glClearNamedFramebufferuiv(" << framebuffer << ", " << toHex(buffer) << ", " << drawbuffer << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.clearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
 }
 
@@ -653,14 +653,14 @@ void CallLogWrapper::glCopyTextureSubImage3D (glw::GLuint texture, glw::GLint le
 void CallLogWrapper::glCreateBuffers (glw::GLsizei n, glw::GLuint *buffers)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glCreateBuffers(" << n << ", " << buffers << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glCreateBuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ");" << TestLog::EndMessage;
        m_gl.createBuffers(n, buffers);
 }
 
 void CallLogWrapper::glCreateFramebuffers (glw::GLsizei n, glw::GLuint *framebuffers)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glCreateFramebuffers(" << n << ", " << framebuffers << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glCreateFramebuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(framebuffers))) << ");" << TestLog::EndMessage;
        m_gl.createFramebuffers(n, framebuffers);
 }
 
@@ -677,28 +677,28 @@ glw::GLuint CallLogWrapper::glCreateProgram (void)
 void CallLogWrapper::glCreateProgramPipelines (glw::GLsizei n, glw::GLuint *pipelines)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glCreateProgramPipelines(" << n << ", " << pipelines << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glCreateProgramPipelines(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(pipelines))) << ");" << TestLog::EndMessage;
        m_gl.createProgramPipelines(n, pipelines);
 }
 
 void CallLogWrapper::glCreateQueries (glw::GLenum target, glw::GLsizei n, glw::GLuint *ids)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glCreateQueries(" << toHex(target) << ", " << n << ", " << ids << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glCreateQueries(" << toHex(target) << ", " << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
        m_gl.createQueries(target, n, ids);
 }
 
 void CallLogWrapper::glCreateRenderbuffers (glw::GLsizei n, glw::GLuint *renderbuffers)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glCreateRenderbuffers(" << n << ", " << renderbuffers << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glCreateRenderbuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(renderbuffers))) << ");" << TestLog::EndMessage;
        m_gl.createRenderbuffers(n, renderbuffers);
 }
 
 void CallLogWrapper::glCreateSamplers (glw::GLsizei n, glw::GLuint *samplers)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glCreateSamplers(" << n << ", " << samplers << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glCreateSamplers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(samplers))) << ");" << TestLog::EndMessage;
        m_gl.createSamplers(n, samplers);
 }
 
@@ -715,7 +715,7 @@ glw::GLuint CallLogWrapper::glCreateShader (glw::GLenum type)
 glw::GLuint CallLogWrapper::glCreateShaderProgramv (glw::GLenum type, glw::GLsizei count, const glw::GLchar *const*strings)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glCreateShaderProgramv(" << toHex(type) << ", " << count << ", " << strings << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glCreateShaderProgramv(" << toHex(type) << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(strings))) << ");" << TestLog::EndMessage;
        glw::GLuint returnValue = m_gl.createShaderProgramv(type, count, strings);
        if (m_enableLog)
                m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
@@ -725,21 +725,21 @@ glw::GLuint CallLogWrapper::glCreateShaderProgramv (glw::GLenum type, glw::GLsiz
 void CallLogWrapper::glCreateTextures (glw::GLenum target, glw::GLsizei n, glw::GLuint *textures)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glCreateTextures(" << toHex(target) << ", " << n << ", " << textures << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glCreateTextures(" << toHex(target) << ", " << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(textures))) << ");" << TestLog::EndMessage;
        m_gl.createTextures(target, n, textures);
 }
 
 void CallLogWrapper::glCreateTransformFeedbacks (glw::GLsizei n, glw::GLuint *ids)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glCreateTransformFeedbacks(" << n << ", " << ids << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glCreateTransformFeedbacks(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
        m_gl.createTransformFeedbacks(n, ids);
 }
 
 void CallLogWrapper::glCreateVertexArrays (glw::GLsizei n, glw::GLuint *arrays)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glCreateVertexArrays(" << n << ", " << arrays << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glCreateVertexArrays(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(arrays))) << ");" << TestLog::EndMessage;
        m_gl.createVertexArrays(n, arrays);
 }
 
@@ -753,7 +753,7 @@ void CallLogWrapper::glCullFace (glw::GLenum mode)
 void CallLogWrapper::glDebugMessageCallback (glw::GLDEBUGPROC callback, const void *userParam)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glDebugMessageCallback(" << ((const void*)(callback)) << ", " << static_cast<const void*>(userParam) << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glDebugMessageCallback(" << toHex(reinterpret_cast<deUintptr>(callback)) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(userParam))) << ");" << TestLog::EndMessage;
        m_gl.debugMessageCallback(callback, userParam);
 }
 
@@ -816,7 +816,7 @@ void CallLogWrapper::glDeleteRenderbuffers (glw::GLsizei n, const glw::GLuint *r
 void CallLogWrapper::glDeleteSamplers (glw::GLsizei count, const glw::GLuint *samplers)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glDeleteSamplers(" << count << ", " << samplers << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glDeleteSamplers(" << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(samplers))) << ");" << TestLog::EndMessage;
        m_gl.deleteSamplers(count, samplers);
 }
 
@@ -844,7 +844,7 @@ void CallLogWrapper::glDeleteTextures (glw::GLsizei n, const glw::GLuint *textur
 void CallLogWrapper::glDeleteTransformFeedbacks (glw::GLsizei n, const glw::GLuint *ids)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glDeleteTransformFeedbacks(" << n << ", " << ids << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glDeleteTransformFeedbacks(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
        m_gl.deleteTransformFeedbacks(n, ids);
 }
 
@@ -879,7 +879,7 @@ void CallLogWrapper::glDepthRange (glw::GLdouble near, glw::GLdouble far)
 void CallLogWrapper::glDepthRangeArrayv (glw::GLuint first, glw::GLsizei count, const glw::GLdouble *v)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glDepthRangeArrayv(" << first << ", " << count << ", " << v << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glDepthRangeArrayv(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
        m_gl.depthRangeArrayv(first, count, v);
 }
 
@@ -1246,7 +1246,7 @@ void CallLogWrapper::glFrontFace (glw::GLenum mode)
 void CallLogWrapper::glGenBuffers (glw::GLsizei n, glw::GLuint *buffers)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGenBuffers(" << n << ", " << buffers << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGenBuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ");" << TestLog::EndMessage;
        m_gl.genBuffers(n, buffers);
        if (m_enableLog)
                m_log << TestLog::Message << "// buffers = " << getPointerStr(buffers, n) << TestLog::EndMessage;
@@ -1255,7 +1255,7 @@ void CallLogWrapper::glGenBuffers (glw::GLsizei n, glw::GLuint *buffers)
 void CallLogWrapper::glGenFramebuffers (glw::GLsizei n, glw::GLuint *framebuffers)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGenFramebuffers(" << n << ", " << framebuffers << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGenFramebuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(framebuffers))) << ");" << TestLog::EndMessage;
        m_gl.genFramebuffers(n, framebuffers);
        if (m_enableLog)
                m_log << TestLog::Message << "// framebuffers = " << getPointerStr(framebuffers, n) << TestLog::EndMessage;
@@ -1264,7 +1264,7 @@ void CallLogWrapper::glGenFramebuffers (glw::GLsizei n, glw::GLuint *framebuffer
 void CallLogWrapper::glGenProgramPipelines (glw::GLsizei n, glw::GLuint *pipelines)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGenProgramPipelines(" << n << ", " << pipelines << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGenProgramPipelines(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(pipelines))) << ");" << TestLog::EndMessage;
        m_gl.genProgramPipelines(n, pipelines);
        if (m_enableLog)
                m_log << TestLog::Message << "// pipelines = " << getPointerStr(pipelines, n) << TestLog::EndMessage;
@@ -1273,7 +1273,7 @@ void CallLogWrapper::glGenProgramPipelines (glw::GLsizei n, glw::GLuint *pipelin
 void CallLogWrapper::glGenQueries (glw::GLsizei n, glw::GLuint *ids)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGenQueries(" << n << ", " << ids << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGenQueries(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
        m_gl.genQueries(n, ids);
        if (m_enableLog)
                m_log << TestLog::Message << "// ids = " << getPointerStr(ids, n) << TestLog::EndMessage;
@@ -1282,7 +1282,7 @@ void CallLogWrapper::glGenQueries (glw::GLsizei n, glw::GLuint *ids)
 void CallLogWrapper::glGenRenderbuffers (glw::GLsizei n, glw::GLuint *renderbuffers)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGenRenderbuffers(" << n << ", " << renderbuffers << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGenRenderbuffers(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(renderbuffers))) << ");" << TestLog::EndMessage;
        m_gl.genRenderbuffers(n, renderbuffers);
        if (m_enableLog)
                m_log << TestLog::Message << "// renderbuffers = " << getPointerStr(renderbuffers, n) << TestLog::EndMessage;
@@ -1291,14 +1291,14 @@ void CallLogWrapper::glGenRenderbuffers (glw::GLsizei n, glw::GLuint *renderbuff
 void CallLogWrapper::glGenSamplers (glw::GLsizei count, glw::GLuint *samplers)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGenSamplers(" << count << ", " << samplers << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGenSamplers(" << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(samplers))) << ");" << TestLog::EndMessage;
        m_gl.genSamplers(count, samplers);
 }
 
 void CallLogWrapper::glGenTextures (glw::GLsizei n, glw::GLuint *textures)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGenTextures(" << n << ", " << textures << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGenTextures(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(textures))) << ");" << TestLog::EndMessage;
        m_gl.genTextures(n, textures);
        if (m_enableLog)
                m_log << TestLog::Message << "// textures = " << getPointerStr(textures, n) << TestLog::EndMessage;
@@ -1307,7 +1307,7 @@ void CallLogWrapper::glGenTextures (glw::GLsizei n, glw::GLuint *textures)
 void CallLogWrapper::glGenTransformFeedbacks (glw::GLsizei n, glw::GLuint *ids)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGenTransformFeedbacks(" << n << ", " << ids << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGenTransformFeedbacks(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ");" << TestLog::EndMessage;
        m_gl.genTransformFeedbacks(n, ids);
        if (m_enableLog)
                m_log << TestLog::Message << "// ids = " << getPointerStr(ids, n) << TestLog::EndMessage;
@@ -1316,7 +1316,7 @@ void CallLogWrapper::glGenTransformFeedbacks (glw::GLsizei n, glw::GLuint *ids)
 void CallLogWrapper::glGenVertexArrays (glw::GLsizei n, glw::GLuint *arrays)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGenVertexArrays(" << n << ", " << arrays << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGenVertexArrays(" << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(arrays))) << ");" << TestLog::EndMessage;
        m_gl.genVertexArrays(n, arrays);
        if (m_enableLog)
                m_log << TestLog::Message << "// arrays = " << getPointerStr(arrays, n) << TestLog::EndMessage;
@@ -1339,42 +1339,42 @@ void CallLogWrapper::glGenerateTextureMipmap (glw::GLuint texture)
 void CallLogWrapper::glGetActiveAtomicCounterBufferiv (glw::GLuint program, glw::GLuint bufferIndex, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetActiveAtomicCounterBufferiv(" << program << ", " << bufferIndex << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetActiveAtomicCounterBufferiv(" << program << ", " << bufferIndex << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
 }
 
 void CallLogWrapper::glGetActiveAttrib (glw::GLuint program, glw::GLuint index, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLint *size, glw::GLenum *type, glw::GLchar *name)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetActiveAttrib(" << program << ", " << index << ", " << bufSize << ", " << length << ", " << size << ", " << type << ", " << name << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetActiveAttrib(" << program << ", " << index << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(size))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(type))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(name))) << ");" << TestLog::EndMessage;
        m_gl.getActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 void CallLogWrapper::glGetActiveSubroutineName (glw::GLuint program, glw::GLenum shadertype, glw::GLuint index, glw::GLsizei bufsize, glw::GLsizei *length, glw::GLchar *name)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetActiveSubroutineName(" << program << ", " << toHex(shadertype) << ", " << index << ", " << bufsize << ", " << length << ", " << name << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetActiveSubroutineName(" << program << ", " << toHex(shadertype) << ", " << index << ", " << bufsize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(name))) << ");" << TestLog::EndMessage;
        m_gl.getActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 void CallLogWrapper::glGetActiveSubroutineUniformName (glw::GLuint program, glw::GLenum shadertype, glw::GLuint index, glw::GLsizei bufsize, glw::GLsizei *length, glw::GLchar *name)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetActiveSubroutineUniformName(" << program << ", " << toHex(shadertype) << ", " << index << ", " << bufsize << ", " << length << ", " << name << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetActiveSubroutineUniformName(" << program << ", " << toHex(shadertype) << ", " << index << ", " << bufsize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(name))) << ");" << TestLog::EndMessage;
        m_gl.getActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 void CallLogWrapper::glGetActiveSubroutineUniformiv (glw::GLuint program, glw::GLenum shadertype, glw::GLuint index, glw::GLenum pname, glw::GLint *values)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetActiveSubroutineUniformiv(" << program << ", " << toHex(shadertype) << ", " << index << ", " << toHex(pname) << ", " << values << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetActiveSubroutineUniformiv(" << program << ", " << toHex(shadertype) << ", " << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(values))) << ");" << TestLog::EndMessage;
        m_gl.getActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 void CallLogWrapper::glGetActiveUniform (glw::GLuint program, glw::GLuint index, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLint *size, glw::GLenum *type, glw::GLchar *name)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetActiveUniform(" << program << ", " << index << ", " << bufSize << ", " << length << ", " << size << ", " << type << ", " << name << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetActiveUniform(" << program << ", " << index << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(size))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(type))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(name))) << ");" << TestLog::EndMessage;
        m_gl.getActiveUniform(program, index, bufSize, length, size, type, name);
        if (m_enableLog)
        {
@@ -1388,28 +1388,28 @@ void CallLogWrapper::glGetActiveUniform (glw::GLuint program, glw::GLuint index,
 void CallLogWrapper::glGetActiveUniformBlockName (glw::GLuint program, glw::GLuint uniformBlockIndex, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *uniformBlockName)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetActiveUniformBlockName(" << program << ", " << uniformBlockIndex << ", " << bufSize << ", " << length << ", " << uniformBlockName << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetActiveUniformBlockName(" << program << ", " << uniformBlockIndex << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(uniformBlockName))) << ");" << TestLog::EndMessage;
        m_gl.getActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 void CallLogWrapper::glGetActiveUniformBlockiv (glw::GLuint program, glw::GLuint uniformBlockIndex, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetActiveUniformBlockiv(" << program << ", " << uniformBlockIndex << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetActiveUniformBlockiv(" << program << ", " << uniformBlockIndex << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 void CallLogWrapper::glGetActiveUniformName (glw::GLuint program, glw::GLuint uniformIndex, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *uniformName)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetActiveUniformName(" << program << ", " << uniformIndex << ", " << bufSize << ", " << length << ", " << uniformName << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetActiveUniformName(" << program << ", " << uniformIndex << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(uniformName))) << ");" << TestLog::EndMessage;
        m_gl.getActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 void CallLogWrapper::glGetActiveUniformsiv (glw::GLuint program, glw::GLsizei uniformCount, const glw::GLuint *uniformIndices, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetActiveUniformsiv(" << program << ", " << uniformCount << ", " << getPointerStr(uniformIndices, uniformCount) << ", " << getUniformParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetActiveUniformsiv(" << program << ", " << uniformCount << ", " << getPointerStr(uniformIndices, uniformCount) << ", " << getUniformParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, uniformCount) << TestLog::EndMessage;
@@ -1418,7 +1418,7 @@ void CallLogWrapper::glGetActiveUniformsiv (glw::GLuint program, glw::GLsizei un
 void CallLogWrapper::glGetAttachedShaders (glw::GLuint program, glw::GLsizei maxCount, glw::GLsizei *count, glw::GLuint *shaders)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetAttachedShaders(" << program << ", " << maxCount << ", " << count << ", " << shaders << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetAttachedShaders(" << program << ", " << maxCount << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(count))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(shaders))) << ");" << TestLog::EndMessage;
        m_gl.getAttachedShaders(program, maxCount, count, shaders);
 }
 
@@ -1435,7 +1435,7 @@ glw::GLint CallLogWrapper::glGetAttribLocation (glw::GLuint program, const glw::
 void CallLogWrapper::glGetBooleani_v (glw::GLenum target, glw::GLuint index, glw::GLboolean *data)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetBooleani_v(" << getGettableIndexedStateStr(target) << ", " << index << ", " << static_cast<const void*>(data) << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetBooleani_v(" << getGettableIndexedStateStr(target) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
        m_gl.getBooleani_v(target, index, data);
        if (m_enableLog)
                m_log << TestLog::Message << "// data = " << getBooleanPointerStr(data, getIndexedQueryNumArgsOut(target)) << TestLog::EndMessage;
@@ -1444,7 +1444,7 @@ void CallLogWrapper::glGetBooleani_v (glw::GLenum target, glw::GLuint index, glw
 void CallLogWrapper::glGetBooleanv (glw::GLenum pname, glw::GLboolean *data)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetBooleanv(" << getGettableStateStr(pname) << ", " << static_cast<const void*>(data) << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetBooleanv(" << getGettableStateStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
        m_gl.getBooleanv(pname, data);
        if (m_enableLog)
                m_log << TestLog::Message << "// data = " << getBooleanPointerStr(data, getBasicQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -1453,21 +1453,21 @@ void CallLogWrapper::glGetBooleanv (glw::GLenum pname, glw::GLboolean *data)
 void CallLogWrapper::glGetBufferParameteri64v (glw::GLenum target, glw::GLenum pname, glw::GLint64 *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetBufferParameteri64v(" << getBufferTargetStr(target) << ", " << getBufferQueryStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetBufferParameteri64v(" << getBufferTargetStr(target) << ", " << getBufferQueryStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getBufferParameteri64v(target, pname, params);
 }
 
 void CallLogWrapper::glGetBufferParameteriv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetBufferParameteriv(" << getBufferTargetStr(target) << ", " << getBufferQueryStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetBufferParameteriv(" << getBufferTargetStr(target) << ", " << getBufferQueryStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getBufferParameteriv(target, pname, params);
 }
 
 void CallLogWrapper::glGetBufferPointerv (glw::GLenum target, glw::GLenum pname, void **params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetBufferPointerv(" << toHex(target) << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetBufferPointerv(" << toHex(target) << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getBufferPointerv(target, pname, params);
 }
 
@@ -1502,7 +1502,7 @@ void CallLogWrapper::glGetCompressedTextureSubImage (glw::GLuint texture, glw::G
 glw::GLuint CallLogWrapper::glGetDebugMessageLog (glw::GLuint count, glw::GLsizei bufSize, glw::GLenum *sources, glw::GLenum *types, glw::GLuint *ids, glw::GLenum *severities, glw::GLsizei *lengths, glw::GLchar *messageLog)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetDebugMessageLog(" << count << ", " << bufSize << ", " << sources << ", " << types << ", " << ids << ", " << severities << ", " << lengths << ", " << messageLog << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetDebugMessageLog(" << count << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(sources))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(types))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(ids))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(severities))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(lengths))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(messageLog))) << ");" << TestLog::EndMessage;
        glw::GLuint returnValue = m_gl.getDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
        if (m_enableLog)
                m_log << TestLog::Message << "// " << returnValue << " returned" << TestLog::EndMessage;
@@ -1512,14 +1512,14 @@ glw::GLuint CallLogWrapper::glGetDebugMessageLog (glw::GLuint count, glw::GLsize
 void CallLogWrapper::glGetDoublei_v (glw::GLenum target, glw::GLuint index, glw::GLdouble *data)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetDoublei_v(" << toHex(target) << ", " << index << ", " << data << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetDoublei_v(" << toHex(target) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
        m_gl.getDoublei_v(target, index, data);
 }
 
 void CallLogWrapper::glGetDoublev (glw::GLenum pname, glw::GLdouble *data)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetDoublev(" << toHex(pname) << ", " << data << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetDoublev(" << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
        m_gl.getDoublev(pname, data);
 }
 
@@ -1536,14 +1536,14 @@ glw::GLenum CallLogWrapper::glGetError (void)
 void CallLogWrapper::glGetFloati_v (glw::GLenum target, glw::GLuint index, glw::GLfloat *data)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetFloati_v(" << toHex(target) << ", " << index << ", " << data << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetFloati_v(" << toHex(target) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
        m_gl.getFloati_v(target, index, data);
 }
 
 void CallLogWrapper::glGetFloatv (glw::GLenum pname, glw::GLfloat *data)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetFloatv(" << getGettableStateStr(pname) << ", " << data << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetFloatv(" << getGettableStateStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
        m_gl.getFloatv(pname, data);
        if (m_enableLog)
                m_log << TestLog::Message << "// data = " << getPointerStr(data, getBasicQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -1572,7 +1572,7 @@ glw::GLint CallLogWrapper::glGetFragDataLocation (glw::GLuint program, const glw
 void CallLogWrapper::glGetFramebufferAttachmentParameteriv (glw::GLenum target, glw::GLenum attachment, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetFramebufferAttachmentParameteriv(" << getFramebufferTargetStr(target) << ", " << getFramebufferAttachmentStr(attachment) << ", " << getFramebufferAttachmentParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetFramebufferAttachmentParameteriv(" << getFramebufferTargetStr(target) << ", " << getFramebufferAttachmentStr(attachment) << ", " << getFramebufferAttachmentParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getFramebufferAttachmentParameteriv(target, attachment, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getFramebufferAttachmentParameterValueStr(pname, params) << TestLog::EndMessage;
@@ -1581,7 +1581,7 @@ void CallLogWrapper::glGetFramebufferAttachmentParameteriv (glw::GLenum target,
 void CallLogWrapper::glGetFramebufferParameteriv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetFramebufferParameteriv(" << getFramebufferTargetStr(target) << ", " << getFramebufferParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetFramebufferParameteriv(" << getFramebufferTargetStr(target) << ", " << getFramebufferParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getFramebufferParameteriv(target, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -1600,7 +1600,7 @@ glw::GLenum CallLogWrapper::glGetGraphicsResetStatus (void)
 void CallLogWrapper::glGetInteger64i_v (glw::GLenum target, glw::GLuint index, glw::GLint64 *data)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetInteger64i_v(" << getGettableIndexedStateStr(target) << ", " << index << ", " << data << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetInteger64i_v(" << getGettableIndexedStateStr(target) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
        m_gl.getInteger64i_v(target, index, data);
        if (m_enableLog)
                m_log << TestLog::Message << "// data = " << getPointerStr(data, getIndexedQueryNumArgsOut(target)) << TestLog::EndMessage;
@@ -1609,7 +1609,7 @@ void CallLogWrapper::glGetInteger64i_v (glw::GLenum target, glw::GLuint index, g
 void CallLogWrapper::glGetInteger64v (glw::GLenum pname, glw::GLint64 *data)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetInteger64v(" << getGettableStateStr(pname) << ", " << data << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetInteger64v(" << getGettableStateStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
        m_gl.getInteger64v(pname, data);
        if (m_enableLog)
                m_log << TestLog::Message << "// data = " << getPointerStr(data, getBasicQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -1618,7 +1618,7 @@ void CallLogWrapper::glGetInteger64v (glw::GLenum pname, glw::GLint64 *data)
 void CallLogWrapper::glGetIntegeri_v (glw::GLenum target, glw::GLuint index, glw::GLint *data)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetIntegeri_v(" << getGettableIndexedStateStr(target) << ", " << index << ", " << data << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetIntegeri_v(" << getGettableIndexedStateStr(target) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
        m_gl.getIntegeri_v(target, index, data);
        if (m_enableLog)
                m_log << TestLog::Message << "// data = " << getPointerStr(data, getIndexedQueryNumArgsOut(target)) << TestLog::EndMessage;
@@ -1627,7 +1627,7 @@ void CallLogWrapper::glGetIntegeri_v (glw::GLenum target, glw::GLuint index, glw
 void CallLogWrapper::glGetIntegerv (glw::GLenum pname, glw::GLint *data)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetIntegerv(" << getGettableStateStr(pname) << ", " << data << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetIntegerv(" << getGettableStateStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(data))) << ");" << TestLog::EndMessage;
        m_gl.getIntegerv(pname, data);
        if (m_enableLog)
                m_log << TestLog::Message << "// data = " << getPointerStr(data, getBasicQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -1636,14 +1636,14 @@ void CallLogWrapper::glGetIntegerv (glw::GLenum pname, glw::GLint *data)
 void CallLogWrapper::glGetInternalformati64v (glw::GLenum target, glw::GLenum internalformat, glw::GLenum pname, glw::GLsizei bufSize, glw::GLint64 *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetInternalformati64v(" << toHex(target) << ", " << toHex(internalformat) << ", " << toHex(pname) << ", " << bufSize << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetInternalformati64v(" << toHex(target) << ", " << toHex(internalformat) << ", " << toHex(pname) << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getInternalformati64v(target, internalformat, pname, bufSize, params);
 }
 
 void CallLogWrapper::glGetInternalformativ (glw::GLenum target, glw::GLenum internalformat, glw::GLenum pname, glw::GLsizei bufSize, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetInternalformativ(" << getInternalFormatTargetStr(target) << ", " << getPixelFormatStr(internalformat) << ", " << getInternalFormatParameterStr(pname) << ", " << bufSize << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetInternalformativ(" << getInternalFormatTargetStr(target) << ", " << getPixelFormatStr(internalformat) << ", " << getInternalFormatParameterStr(pname) << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getInternalformativ(target, internalformat, pname, bufSize, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, bufSize) << TestLog::EndMessage;
@@ -1652,7 +1652,7 @@ void CallLogWrapper::glGetInternalformativ (glw::GLenum target, glw::GLenum inte
 void CallLogWrapper::glGetMultisamplefv (glw::GLenum pname, glw::GLuint index, glw::GLfloat *val)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetMultisamplefv(" << getMultisampleParameterStr(pname) << ", " << index << ", " << val << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetMultisamplefv(" << getMultisampleParameterStr(pname) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(val))) << ");" << TestLog::EndMessage;
        m_gl.getMultisamplefv(pname, index, val);
        if (m_enableLog)
                m_log << TestLog::Message << "// val = " << getPointerStr(val, 2) << TestLog::EndMessage;
@@ -1661,21 +1661,21 @@ void CallLogWrapper::glGetMultisamplefv (glw::GLenum pname, glw::GLuint index, g
 void CallLogWrapper::glGetNamedBufferParameteri64v (glw::GLuint buffer, glw::GLenum pname, glw::GLint64 *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetNamedBufferParameteri64v(" << buffer << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetNamedBufferParameteri64v(" << buffer << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getNamedBufferParameteri64v(buffer, pname, params);
 }
 
 void CallLogWrapper::glGetNamedBufferParameteriv (glw::GLuint buffer, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetNamedBufferParameteriv(" << buffer << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetNamedBufferParameteriv(" << buffer << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getNamedBufferParameteriv(buffer, pname, params);
 }
 
 void CallLogWrapper::glGetNamedBufferPointerv (glw::GLuint buffer, glw::GLenum pname, void **params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetNamedBufferPointerv(" << buffer << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetNamedBufferPointerv(" << buffer << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getNamedBufferPointerv(buffer, pname, params);
 }
 
@@ -1689,42 +1689,42 @@ void CallLogWrapper::glGetNamedBufferSubData (glw::GLuint buffer, glw::GLintptr
 void CallLogWrapper::glGetNamedFramebufferAttachmentParameteriv (glw::GLuint framebuffer, glw::GLenum attachment, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetNamedFramebufferAttachmentParameteriv(" << framebuffer << ", " << toHex(attachment) << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetNamedFramebufferAttachmentParameteriv(" << framebuffer << ", " << toHex(attachment) << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
 }
 
 void CallLogWrapper::glGetNamedFramebufferParameteriv (glw::GLuint framebuffer, glw::GLenum pname, glw::GLint *param)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetNamedFramebufferParameteriv(" << framebuffer << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetNamedFramebufferParameteriv(" << framebuffer << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
        m_gl.getNamedFramebufferParameteriv(framebuffer, pname, param);
 }
 
 void CallLogWrapper::glGetNamedRenderbufferParameteriv (glw::GLuint renderbuffer, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetNamedRenderbufferParameteriv(" << renderbuffer << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetNamedRenderbufferParameteriv(" << renderbuffer << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getNamedRenderbufferParameteriv(renderbuffer, pname, params);
 }
 
 void CallLogWrapper::glGetObjectLabel (glw::GLenum identifier, glw::GLuint name, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *label)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetObjectLabel(" << toHex(identifier) << ", " << name << ", " << bufSize << ", " << length << ", " << label << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetObjectLabel(" << toHex(identifier) << ", " << name << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(label))) << ");" << TestLog::EndMessage;
        m_gl.getObjectLabel(identifier, name, bufSize, length, label);
 }
 
 void CallLogWrapper::glGetObjectPtrLabel (const void *ptr, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *label)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetObjectPtrLabel(" << ptr << ", " << bufSize << ", " << length << ", " << label << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetObjectPtrLabel(" << ptr << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(label))) << ");" << TestLog::EndMessage;
        m_gl.getObjectPtrLabel(ptr, bufSize, length, label);
 }
 
 void CallLogWrapper::glGetPointerv (glw::GLenum pname, void **params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetPointerv(" << getPointerStateStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetPointerv(" << getPointerStateStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getPointerv(pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -1733,14 +1733,14 @@ void CallLogWrapper::glGetPointerv (glw::GLenum pname, void **params)
 void CallLogWrapper::glGetProgramBinary (glw::GLuint program, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLenum *binaryFormat, void *binary)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetProgramBinary(" << program << ", " << bufSize << ", " << length << ", " << binaryFormat << ", " << binary << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetProgramBinary(" << program << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(binaryFormat))) << ", " << binary << ");" << TestLog::EndMessage;
        m_gl.getProgramBinary(program, bufSize, length, binaryFormat, binary);
 }
 
 void CallLogWrapper::glGetProgramInfoLog (glw::GLuint program, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *infoLog)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetProgramInfoLog(" << program << ", " << bufSize << ", " << length << ", " << static_cast<const void*>(infoLog) << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetProgramInfoLog(" << program << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(infoLog))) << ");" << TestLog::EndMessage;
        m_gl.getProgramInfoLog(program, bufSize, length, infoLog);
        if (m_enableLog)
                m_log << TestLog::Message << "// length = " << getPointerStr(length, 1) << TestLog::EndMessage;
@@ -1749,14 +1749,14 @@ void CallLogWrapper::glGetProgramInfoLog (glw::GLuint program, glw::GLsizei bufS
 void CallLogWrapper::glGetProgramInterfaceiv (glw::GLuint program, glw::GLenum programInterface, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetProgramInterfaceiv(" << program << ", " << toHex(programInterface) << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetProgramInterfaceiv(" << program << ", " << toHex(programInterface) << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getProgramInterfaceiv(program, programInterface, pname, params);
 }
 
 void CallLogWrapper::glGetProgramPipelineInfoLog (glw::GLuint pipeline, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *infoLog)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetProgramPipelineInfoLog(" << pipeline << ", " << bufSize << ", " << length << ", " << static_cast<const void*>(infoLog) << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetProgramPipelineInfoLog(" << pipeline << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(infoLog))) << ");" << TestLog::EndMessage;
        m_gl.getProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
        if (m_enableLog)
                m_log << TestLog::Message << "// length = " << getPointerStr(length, 1) << TestLog::EndMessage;
@@ -1765,7 +1765,7 @@ void CallLogWrapper::glGetProgramPipelineInfoLog (glw::GLuint pipeline, glw::GLs
 void CallLogWrapper::glGetProgramPipelineiv (glw::GLuint pipeline, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetProgramPipelineiv(" << pipeline << ", " << getPipelineParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetProgramPipelineiv(" << pipeline << ", " << getPipelineParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getProgramPipelineiv(pipeline, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -1804,14 +1804,14 @@ glw::GLint CallLogWrapper::glGetProgramResourceLocationIndex (glw::GLuint progra
 void CallLogWrapper::glGetProgramResourceName (glw::GLuint program, glw::GLenum programInterface, glw::GLuint index, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *name)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetProgramResourceName(" << program << ", " << toHex(programInterface) << ", " << index << ", " << bufSize << ", " << length << ", " << name << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetProgramResourceName(" << program << ", " << toHex(programInterface) << ", " << index << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(name))) << ");" << TestLog::EndMessage;
        m_gl.getProgramResourceName(program, programInterface, index, bufSize, length, name);
 }
 
 void CallLogWrapper::glGetProgramResourceiv (glw::GLuint program, glw::GLenum programInterface, glw::GLuint index, glw::GLsizei propCount, const glw::GLenum *props, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetProgramResourceiv(" << program << ", " << getProgramInterfaceStr(programInterface) << ", " << index << ", " << propCount << ", " << getEnumPointerStr(props, propCount, getProgramResourcePropertyName) << ", " << bufSize << ", " << length << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetProgramResourceiv(" << program << ", " << getProgramInterfaceStr(programInterface) << ", " << index << ", " << propCount << ", " << getEnumPointerStr(props, propCount, getProgramResourcePropertyName) << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
        if (m_enableLog)
        {
@@ -1823,14 +1823,14 @@ void CallLogWrapper::glGetProgramResourceiv (glw::GLuint program, glw::GLenum pr
 void CallLogWrapper::glGetProgramStageiv (glw::GLuint program, glw::GLenum shadertype, glw::GLenum pname, glw::GLint *values)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetProgramStageiv(" << program << ", " << toHex(shadertype) << ", " << toHex(pname) << ", " << values << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetProgramStageiv(" << program << ", " << toHex(shadertype) << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(values))) << ");" << TestLog::EndMessage;
        m_gl.getProgramStageiv(program, shadertype, pname, values);
 }
 
 void CallLogWrapper::glGetProgramiv (glw::GLuint program, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetProgramiv(" << program << ", " << getProgramParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetProgramiv(" << program << ", " << getProgramParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getProgramiv(program, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, getProgramQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -1867,14 +1867,14 @@ void CallLogWrapper::glGetQueryBufferObjectuiv (glw::GLuint id, glw::GLuint buff
 void CallLogWrapper::glGetQueryIndexediv (glw::GLenum target, glw::GLuint index, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetQueryIndexediv(" << toHex(target) << ", " << index << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetQueryIndexediv(" << toHex(target) << ", " << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getQueryIndexediv(target, index, pname, params);
 }
 
 void CallLogWrapper::glGetQueryObjecti64v (glw::GLuint id, glw::GLenum pname, glw::GLint64 *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetQueryObjecti64v(" << id << ", " << getQueryObjectParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetQueryObjecti64v(" << id << ", " << getQueryObjectParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getQueryObjecti64v(id, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -1883,7 +1883,7 @@ void CallLogWrapper::glGetQueryObjecti64v (glw::GLuint id, glw::GLenum pname, gl
 void CallLogWrapper::glGetQueryObjectiv (glw::GLuint id, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetQueryObjectiv(" << id << ", " << getQueryObjectParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetQueryObjectiv(" << id << ", " << getQueryObjectParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getQueryObjectiv(id, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -1892,7 +1892,7 @@ void CallLogWrapper::glGetQueryObjectiv (glw::GLuint id, glw::GLenum pname, glw:
 void CallLogWrapper::glGetQueryObjectui64v (glw::GLuint id, glw::GLenum pname, glw::GLuint64 *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetQueryObjectui64v(" << id << ", " << getQueryObjectParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetQueryObjectui64v(" << id << ", " << getQueryObjectParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getQueryObjectui64v(id, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -1901,7 +1901,7 @@ void CallLogWrapper::glGetQueryObjectui64v (glw::GLuint id, glw::GLenum pname, g
 void CallLogWrapper::glGetQueryObjectuiv (glw::GLuint id, glw::GLenum pname, glw::GLuint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetQueryObjectuiv(" << id << ", " << getQueryObjectParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetQueryObjectuiv(" << id << ", " << getQueryObjectParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getQueryObjectuiv(id, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -1910,7 +1910,7 @@ void CallLogWrapper::glGetQueryObjectuiv (glw::GLuint id, glw::GLenum pname, glw
 void CallLogWrapper::glGetQueryiv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetQueryiv(" << getQueryTargetStr(target) << ", " << getQueryParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetQueryiv(" << getQueryTargetStr(target) << ", " << getQueryParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getQueryiv(target, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -1919,14 +1919,14 @@ void CallLogWrapper::glGetQueryiv (glw::GLenum target, glw::GLenum pname, glw::G
 void CallLogWrapper::glGetRenderbufferParameteriv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetRenderbufferParameteriv(" << getFramebufferTargetStr(target) << ", " << getRenderbufferParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetRenderbufferParameteriv(" << getFramebufferTargetStr(target) << ", " << getRenderbufferParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getRenderbufferParameteriv(target, pname, params);
 }
 
 void CallLogWrapper::glGetSamplerParameterIiv (glw::GLuint sampler, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetSamplerParameterIiv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetSamplerParameterIiv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getSamplerParameterIiv(sampler, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, getTextureParamQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -1935,7 +1935,7 @@ void CallLogWrapper::glGetSamplerParameterIiv (glw::GLuint sampler, glw::GLenum
 void CallLogWrapper::glGetSamplerParameterIuiv (glw::GLuint sampler, glw::GLenum pname, glw::GLuint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetSamplerParameterIuiv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetSamplerParameterIuiv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getSamplerParameterIuiv(sampler, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, getTextureParamQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -1944,7 +1944,7 @@ void CallLogWrapper::glGetSamplerParameterIuiv (glw::GLuint sampler, glw::GLenum
 void CallLogWrapper::glGetSamplerParameterfv (glw::GLuint sampler, glw::GLenum pname, glw::GLfloat *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetSamplerParameterfv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetSamplerParameterfv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getSamplerParameterfv(sampler, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -1953,7 +1953,7 @@ void CallLogWrapper::glGetSamplerParameterfv (glw::GLuint sampler, glw::GLenum p
 void CallLogWrapper::glGetSamplerParameteriv (glw::GLuint sampler, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetSamplerParameteriv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetSamplerParameteriv(" << sampler << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getSamplerParameteriv(sampler, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -1962,7 +1962,7 @@ void CallLogWrapper::glGetSamplerParameteriv (glw::GLuint sampler, glw::GLenum p
 void CallLogWrapper::glGetShaderInfoLog (glw::GLuint shader, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *infoLog)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetShaderInfoLog(" << shader << ", " << bufSize << ", " << length << ", " << static_cast<const void*>(infoLog) << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetShaderInfoLog(" << shader << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(infoLog))) << ");" << TestLog::EndMessage;
        m_gl.getShaderInfoLog(shader, bufSize, length, infoLog);
        if (m_enableLog)
                m_log << TestLog::Message << "// length = " << getPointerStr(length, 1) << TestLog::EndMessage;
@@ -1971,21 +1971,21 @@ void CallLogWrapper::glGetShaderInfoLog (glw::GLuint shader, glw::GLsizei bufSiz
 void CallLogWrapper::glGetShaderPrecisionFormat (glw::GLenum shadertype, glw::GLenum precisiontype, glw::GLint *range, glw::GLint *precision)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetShaderPrecisionFormat(" << getShaderTypeStr(shadertype) << ", " << getPrecisionFormatTypeStr(precisiontype) << ", " << range << ", " << precision << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetShaderPrecisionFormat(" << getShaderTypeStr(shadertype) << ", " << getPrecisionFormatTypeStr(precisiontype) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(range))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(precision))) << ");" << TestLog::EndMessage;
        m_gl.getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
 void CallLogWrapper::glGetShaderSource (glw::GLuint shader, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLchar *source)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetShaderSource(" << shader << ", " << bufSize << ", " << length << ", " << source << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetShaderSource(" << shader << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(source))) << ");" << TestLog::EndMessage;
        m_gl.getShaderSource(shader, bufSize, length, source);
 }
 
 void CallLogWrapper::glGetShaderiv (glw::GLuint shader, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetShaderiv(" << shader << ", " << getShaderParamStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetShaderiv(" << shader << ", " << getShaderParamStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getShaderiv(shader, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -2034,7 +2034,7 @@ glw::GLint CallLogWrapper::glGetSubroutineUniformLocation (glw::GLuint program,
 void CallLogWrapper::glGetSynciv (glw::GLsync sync, glw::GLenum pname, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLint *values)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetSynciv(" << sync << ", " << toHex(pname) << ", " << bufSize << ", " << length << ", " << values << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetSynciv(" << sync << ", " << toHex(pname) << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(values))) << ");" << TestLog::EndMessage;
        m_gl.getSynciv(sync, pname, bufSize, length, values);
 }
 
@@ -2048,7 +2048,7 @@ void CallLogWrapper::glGetTexImage (glw::GLenum target, glw::GLint level, glw::G
 void CallLogWrapper::glGetTexLevelParameterfv (glw::GLenum target, glw::GLint level, glw::GLenum pname, glw::GLfloat *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTexLevelParameterfv(" << getTextureTargetStr(target) << ", " << level << ", " << getTextureLevelParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTexLevelParameterfv(" << getTextureTargetStr(target) << ", " << level << ", " << getTextureLevelParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getTexLevelParameterfv(target, level, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -2057,7 +2057,7 @@ void CallLogWrapper::glGetTexLevelParameterfv (glw::GLenum target, glw::GLint le
 void CallLogWrapper::glGetTexLevelParameteriv (glw::GLenum target, glw::GLint level, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTexLevelParameteriv(" << getTextureTargetStr(target) << ", " << level << ", " << getTextureLevelParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTexLevelParameteriv(" << getTextureTargetStr(target) << ", " << level << ", " << getTextureLevelParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getTexLevelParameteriv(target, level, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -2066,7 +2066,7 @@ void CallLogWrapper::glGetTexLevelParameteriv (glw::GLenum target, glw::GLint le
 void CallLogWrapper::glGetTexParameterIiv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTexParameterIiv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTexParameterIiv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getTexParameterIiv(target, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, getTextureParamQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -2075,7 +2075,7 @@ void CallLogWrapper::glGetTexParameterIiv (glw::GLenum target, glw::GLenum pname
 void CallLogWrapper::glGetTexParameterIuiv (glw::GLenum target, glw::GLenum pname, glw::GLuint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTexParameterIuiv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTexParameterIuiv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getTexParameterIuiv(target, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, getTextureParamQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -2084,7 +2084,7 @@ void CallLogWrapper::glGetTexParameterIuiv (glw::GLenum target, glw::GLenum pnam
 void CallLogWrapper::glGetTexParameterfv (glw::GLenum target, glw::GLenum pname, glw::GLfloat *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTexParameterfv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTexParameterfv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getTexParameterfv(target, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -2093,7 +2093,7 @@ void CallLogWrapper::glGetTexParameterfv (glw::GLenum target, glw::GLenum pname,
 void CallLogWrapper::glGetTexParameteriv (glw::GLenum target, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTexParameteriv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTexParameteriv(" << getTextureTargetStr(target) << ", " << getTextureParameterStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getTexParameteriv(target, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, 1) << TestLog::EndMessage;
@@ -2109,42 +2109,42 @@ void CallLogWrapper::glGetTextureImage (glw::GLuint texture, glw::GLint level, g
 void CallLogWrapper::glGetTextureLevelParameterfv (glw::GLuint texture, glw::GLint level, glw::GLenum pname, glw::GLfloat *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTextureLevelParameterfv(" << texture << ", " << level << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTextureLevelParameterfv(" << texture << ", " << level << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getTextureLevelParameterfv(texture, level, pname, params);
 }
 
 void CallLogWrapper::glGetTextureLevelParameteriv (glw::GLuint texture, glw::GLint level, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTextureLevelParameteriv(" << texture << ", " << level << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTextureLevelParameteriv(" << texture << ", " << level << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getTextureLevelParameteriv(texture, level, pname, params);
 }
 
 void CallLogWrapper::glGetTextureParameterIiv (glw::GLuint texture, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTextureParameterIiv(" << texture << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTextureParameterIiv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getTextureParameterIiv(texture, pname, params);
 }
 
 void CallLogWrapper::glGetTextureParameterIuiv (glw::GLuint texture, glw::GLenum pname, glw::GLuint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTextureParameterIuiv(" << texture << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTextureParameterIuiv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getTextureParameterIuiv(texture, pname, params);
 }
 
 void CallLogWrapper::glGetTextureParameterfv (glw::GLuint texture, glw::GLenum pname, glw::GLfloat *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTextureParameterfv(" << texture << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTextureParameterfv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getTextureParameterfv(texture, pname, params);
 }
 
 void CallLogWrapper::glGetTextureParameteriv (glw::GLuint texture, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTextureParameteriv(" << texture << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTextureParameteriv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getTextureParameteriv(texture, pname, params);
 }
 
@@ -2158,28 +2158,28 @@ void CallLogWrapper::glGetTextureSubImage (glw::GLuint texture, glw::GLint level
 void CallLogWrapper::glGetTransformFeedbackVarying (glw::GLuint program, glw::GLuint index, glw::GLsizei bufSize, glw::GLsizei *length, glw::GLsizei *size, glw::GLenum *type, glw::GLchar *name)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTransformFeedbackVarying(" << program << ", " << index << ", " << bufSize << ", " << length << ", " << size << ", " << type << ", " << name << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTransformFeedbackVarying(" << program << ", " << index << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(size))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(type))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(name))) << ");" << TestLog::EndMessage;
        m_gl.getTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 void CallLogWrapper::glGetTransformFeedbacki64_v (glw::GLuint xfb, glw::GLenum pname, glw::GLuint index, glw::GLint64 *param)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTransformFeedbacki64_v(" << xfb << ", " << toHex(pname) << ", " << index << ", " << param << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTransformFeedbacki64_v(" << xfb << ", " << toHex(pname) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
        m_gl.getTransformFeedbacki64_v(xfb, pname, index, param);
 }
 
 void CallLogWrapper::glGetTransformFeedbacki_v (glw::GLuint xfb, glw::GLenum pname, glw::GLuint index, glw::GLint *param)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTransformFeedbacki_v(" << xfb << ", " << toHex(pname) << ", " << index << ", " << param << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTransformFeedbacki_v(" << xfb << ", " << toHex(pname) << ", " << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
        m_gl.getTransformFeedbacki_v(xfb, pname, index, param);
 }
 
 void CallLogWrapper::glGetTransformFeedbackiv (glw::GLuint xfb, glw::GLenum pname, glw::GLint *param)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetTransformFeedbackiv(" << xfb << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetTransformFeedbackiv(" << xfb << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
        m_gl.getTransformFeedbackiv(xfb, pname, param);
 }
 
@@ -2196,7 +2196,7 @@ glw::GLuint CallLogWrapper::glGetUniformBlockIndex (glw::GLuint program, const g
 void CallLogWrapper::glGetUniformIndices (glw::GLuint program, glw::GLsizei uniformCount, const glw::GLchar *const*uniformNames, glw::GLuint *uniformIndices)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetUniformIndices(" << program << ", " << uniformCount << ", " << getPointerStr(uniformNames, uniformCount) << ", " << uniformIndices << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetUniformIndices(" << program << ", " << uniformCount << ", " << getPointerStr(uniformNames, uniformCount) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(uniformIndices))) << ");" << TestLog::EndMessage;
        m_gl.getUniformIndices(program, uniformCount, uniformNames, uniformIndices);
        if (m_enableLog)
                m_log << TestLog::Message << "// uniformIndices = " << getPointerStr(uniformIndices, uniformCount) << TestLog::EndMessage;
@@ -2215,63 +2215,63 @@ glw::GLint CallLogWrapper::glGetUniformLocation (glw::GLuint program, const glw:
 void CallLogWrapper::glGetUniformSubroutineuiv (glw::GLenum shadertype, glw::GLint location, glw::GLuint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetUniformSubroutineuiv(" << toHex(shadertype) << ", " << location << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetUniformSubroutineuiv(" << toHex(shadertype) << ", " << location << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getUniformSubroutineuiv(shadertype, location, params);
 }
 
 void CallLogWrapper::glGetUniformdv (glw::GLuint program, glw::GLint location, glw::GLdouble *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetUniformdv(" << program << ", " << location << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetUniformdv(" << program << ", " << location << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getUniformdv(program, location, params);
 }
 
 void CallLogWrapper::glGetUniformfv (glw::GLuint program, glw::GLint location, glw::GLfloat *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetUniformfv(" << program << ", " << location << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetUniformfv(" << program << ", " << location << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getUniformfv(program, location, params);
 }
 
 void CallLogWrapper::glGetUniformiv (glw::GLuint program, glw::GLint location, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetUniformiv(" << program << ", " << location << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetUniformiv(" << program << ", " << location << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getUniformiv(program, location, params);
 }
 
 void CallLogWrapper::glGetUniformuiv (glw::GLuint program, glw::GLint location, glw::GLuint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetUniformuiv(" << program << ", " << location << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetUniformuiv(" << program << ", " << location << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getUniformuiv(program, location, params);
 }
 
 void CallLogWrapper::glGetVertexArrayIndexed64iv (glw::GLuint vaobj, glw::GLuint index, glw::GLenum pname, glw::GLint64 *param)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetVertexArrayIndexed64iv(" << vaobj << ", " << index << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetVertexArrayIndexed64iv(" << vaobj << ", " << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
        m_gl.getVertexArrayIndexed64iv(vaobj, index, pname, param);
 }
 
 void CallLogWrapper::glGetVertexArrayIndexediv (glw::GLuint vaobj, glw::GLuint index, glw::GLenum pname, glw::GLint *param)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetVertexArrayIndexediv(" << vaobj << ", " << index << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetVertexArrayIndexediv(" << vaobj << ", " << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
        m_gl.getVertexArrayIndexediv(vaobj, index, pname, param);
 }
 
 void CallLogWrapper::glGetVertexArrayiv (glw::GLuint vaobj, glw::GLenum pname, glw::GLint *param)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetVertexArrayiv(" << vaobj << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetVertexArrayiv(" << vaobj << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
        m_gl.getVertexArrayiv(vaobj, pname, param);
 }
 
 void CallLogWrapper::glGetVertexAttribIiv (glw::GLuint index, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetVertexAttribIiv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetVertexAttribIiv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getVertexAttribIiv(index, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, getAttributeQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -2280,7 +2280,7 @@ void CallLogWrapper::glGetVertexAttribIiv (glw::GLuint index, glw::GLenum pname,
 void CallLogWrapper::glGetVertexAttribIuiv (glw::GLuint index, glw::GLenum pname, glw::GLuint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetVertexAttribIuiv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetVertexAttribIuiv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getVertexAttribIuiv(index, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, getAttributeQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -2289,28 +2289,28 @@ void CallLogWrapper::glGetVertexAttribIuiv (glw::GLuint index, glw::GLenum pname
 void CallLogWrapper::glGetVertexAttribLdv (glw::GLuint index, glw::GLenum pname, glw::GLdouble *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetVertexAttribLdv(" << index << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetVertexAttribLdv(" << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getVertexAttribLdv(index, pname, params);
 }
 
 void CallLogWrapper::glGetVertexAttribPointerv (glw::GLuint index, glw::GLenum pname, void **pointer)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetVertexAttribPointerv(" << index << ", " << toHex(pname) << ", " << pointer << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetVertexAttribPointerv(" << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(pointer))) << ");" << TestLog::EndMessage;
        m_gl.getVertexAttribPointerv(index, pname, pointer);
 }
 
 void CallLogWrapper::glGetVertexAttribdv (glw::GLuint index, glw::GLenum pname, glw::GLdouble *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetVertexAttribdv(" << index << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetVertexAttribdv(" << index << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getVertexAttribdv(index, pname, params);
 }
 
 void CallLogWrapper::glGetVertexAttribfv (glw::GLuint index, glw::GLenum pname, glw::GLfloat *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetVertexAttribfv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetVertexAttribfv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getVertexAttribfv(index, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, getAttributeQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -2319,7 +2319,7 @@ void CallLogWrapper::glGetVertexAttribfv (glw::GLuint index, glw::GLenum pname,
 void CallLogWrapper::glGetVertexAttribiv (glw::GLuint index, glw::GLenum pname, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetVertexAttribiv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetVertexAttribiv(" << index << ", " << getVertexAttribParameterNameStr(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getVertexAttribiv(index, pname, params);
        if (m_enableLog)
                m_log << TestLog::Message << "// params = " << getPointerStr(params, getAttributeQueryNumArgsOut(pname)) << TestLog::EndMessage;
@@ -2342,28 +2342,28 @@ void CallLogWrapper::glGetnTexImage (glw::GLenum target, glw::GLint level, glw::
 void CallLogWrapper::glGetnUniformdv (glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, glw::GLdouble *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetnUniformdv(" << program << ", " << location << ", " << bufSize << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetnUniformdv(" << program << ", " << location << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getnUniformdv(program, location, bufSize, params);
 }
 
 void CallLogWrapper::glGetnUniformfv (glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, glw::GLfloat *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetnUniformfv(" << program << ", " << location << ", " << bufSize << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetnUniformfv(" << program << ", " << location << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getnUniformfv(program, location, bufSize, params);
 }
 
 void CallLogWrapper::glGetnUniformiv (glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetnUniformiv(" << program << ", " << location << ", " << bufSize << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetnUniformiv(" << program << ", " << location << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getnUniformiv(program, location, bufSize, params);
 }
 
 void CallLogWrapper::glGetnUniformuiv (glw::GLuint program, glw::GLint location, glw::GLsizei bufSize, glw::GLuint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glGetnUniformuiv(" << program << ", " << location << ", " << bufSize << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glGetnUniformuiv(" << program << ", " << location << ", " << bufSize << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.getnUniformuiv(program, location, bufSize, params);
 }
 
@@ -2398,14 +2398,14 @@ void CallLogWrapper::glInvalidateFramebuffer (glw::GLenum target, glw::GLsizei n
 void CallLogWrapper::glInvalidateNamedFramebufferData (glw::GLuint framebuffer, glw::GLsizei numAttachments, const glw::GLenum *attachments)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glInvalidateNamedFramebufferData(" << framebuffer << ", " << numAttachments << ", " << attachments << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glInvalidateNamedFramebufferData(" << framebuffer << ", " << numAttachments << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(attachments))) << ");" << TestLog::EndMessage;
        m_gl.invalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
 }
 
 void CallLogWrapper::glInvalidateNamedFramebufferSubData (glw::GLuint framebuffer, glw::GLsizei numAttachments, const glw::GLenum *attachments, glw::GLint x, glw::GLint y, glw::GLsizei width, glw::GLsizei height)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glInvalidateNamedFramebufferSubData(" << framebuffer << ", " << numAttachments << ", " << attachments << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glInvalidateNamedFramebufferSubData(" << framebuffer << ", " << numAttachments << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(attachments))) << ", " << x << ", " << y << ", " << width << ", " << height << ");" << TestLog::EndMessage;
        m_gl.invalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
 }
 
@@ -2655,7 +2655,7 @@ void CallLogWrapper::glMinSampleShading (glw::GLfloat value)
 void CallLogWrapper::glMultiDrawArrays (glw::GLenum mode, const glw::GLint *first, const glw::GLsizei *count, glw::GLsizei drawcount)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glMultiDrawArrays(" << getPrimitiveTypeStr(mode) << ", " << first << ", " << count << ", " << drawcount << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glMultiDrawArrays(" << getPrimitiveTypeStr(mode) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(first))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(count))) << ", " << drawcount << ");" << TestLog::EndMessage;
        m_gl.multiDrawArrays(mode, first, count, drawcount);
 }
 
@@ -2669,14 +2669,14 @@ void CallLogWrapper::glMultiDrawArraysIndirect (glw::GLenum mode, const void *in
 void CallLogWrapper::glMultiDrawElements (glw::GLenum mode, const glw::GLsizei *count, glw::GLenum type, const void *const*indices, glw::GLsizei drawcount)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glMultiDrawElements(" << getPrimitiveTypeStr(mode) << ", " << count << ", " << getTypeStr(type) << ", " << indices << ", " << drawcount << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glMultiDrawElements(" << getPrimitiveTypeStr(mode) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(count))) << ", " << getTypeStr(type) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(indices))) << ", " << drawcount << ");" << TestLog::EndMessage;
        m_gl.multiDrawElements(mode, count, type, indices, drawcount);
 }
 
 void CallLogWrapper::glMultiDrawElementsBaseVertex (glw::GLenum mode, const glw::GLsizei *count, glw::GLenum type, const void *const*indices, glw::GLsizei drawcount, const glw::GLint *basevertex)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glMultiDrawElementsBaseVertex(" << getPrimitiveTypeStr(mode) << ", " << count << ", " << getTypeStr(type) << ", " << indices << ", " << drawcount << ", " << basevertex << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glMultiDrawElementsBaseVertex(" << getPrimitiveTypeStr(mode) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(count))) << ", " << getTypeStr(type) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(indices))) << ", " << drawcount << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(basevertex))) << ");" << TestLog::EndMessage;
        m_gl.multiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
@@ -2718,7 +2718,7 @@ void CallLogWrapper::glNamedFramebufferDrawBuffer (glw::GLuint framebuffer, glw:
 void CallLogWrapper::glNamedFramebufferDrawBuffers (glw::GLuint framebuffer, glw::GLsizei n, const glw::GLenum *bufs)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glNamedFramebufferDrawBuffers(" << framebuffer << ", " << n << ", " << bufs << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glNamedFramebufferDrawBuffers(" << framebuffer << ", " << n << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(bufs))) << ");" << TestLog::EndMessage;
        m_gl.namedFramebufferDrawBuffers(framebuffer, n, bufs);
 }
 
@@ -2788,7 +2788,7 @@ void CallLogWrapper::glObjectPtrLabel (const void *ptr, glw::GLsizei length, con
 void CallLogWrapper::glPatchParameterfv (glw::GLenum pname, const glw::GLfloat *values)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glPatchParameterfv(" << toHex(pname) << ", " << values << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glPatchParameterfv(" << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(values))) << ");" << TestLog::EndMessage;
        m_gl.patchParameterfv(pname, values);
 }
 
@@ -2830,7 +2830,7 @@ void CallLogWrapper::glPointParameterf (glw::GLenum pname, glw::GLfloat param)
 void CallLogWrapper::glPointParameterfv (glw::GLenum pname, const glw::GLfloat *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glPointParameterfv(" << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glPointParameterfv(" << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.pointParameterfv(pname, params);
 }
 
@@ -2844,7 +2844,7 @@ void CallLogWrapper::glPointParameteri (glw::GLenum pname, glw::GLint param)
 void CallLogWrapper::glPointParameteriv (glw::GLenum pname, const glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glPointParameteriv(" << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glPointParameteriv(" << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.pointParameteriv(pname, params);
 }
 
@@ -2914,7 +2914,7 @@ void CallLogWrapper::glProgramUniform1d (glw::GLuint program, glw::GLint locatio
 void CallLogWrapper::glProgramUniform1dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniform1dv(" << program << ", " << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniform1dv(" << program << ", " << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniform1dv(program, location, count, value);
 }
 
@@ -2970,7 +2970,7 @@ void CallLogWrapper::glProgramUniform2d (glw::GLuint program, glw::GLint locatio
 void CallLogWrapper::glProgramUniform2dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniform2dv(" << program << ", " << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniform2dv(" << program << ", " << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniform2dv(program, location, count, value);
 }
 
@@ -3026,7 +3026,7 @@ void CallLogWrapper::glProgramUniform3d (glw::GLuint program, glw::GLint locatio
 void CallLogWrapper::glProgramUniform3dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniform3dv(" << program << ", " << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniform3dv(" << program << ", " << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniform3dv(program, location, count, value);
 }
 
@@ -3082,7 +3082,7 @@ void CallLogWrapper::glProgramUniform4d (glw::GLuint program, glw::GLint locatio
 void CallLogWrapper::glProgramUniform4dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniform4dv(" << program << ", " << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniform4dv(" << program << ", " << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniform4dv(program, location, count, value);
 }
 
@@ -3131,7 +3131,7 @@ void CallLogWrapper::glProgramUniform4uiv (glw::GLuint program, glw::GLint locat
 void CallLogWrapper::glProgramUniformMatrix2dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniformMatrix2dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniformMatrix2dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniformMatrix2dv(program, location, count, transpose, value);
 }
 
@@ -3145,7 +3145,7 @@ void CallLogWrapper::glProgramUniformMatrix2fv (glw::GLuint program, glw::GLint
 void CallLogWrapper::glProgramUniformMatrix2x3dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniformMatrix2x3dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniformMatrix2x3dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniformMatrix2x3dv(program, location, count, transpose, value);
 }
 
@@ -3159,7 +3159,7 @@ void CallLogWrapper::glProgramUniformMatrix2x3fv (glw::GLuint program, glw::GLin
 void CallLogWrapper::glProgramUniformMatrix2x4dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniformMatrix2x4dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniformMatrix2x4dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniformMatrix2x4dv(program, location, count, transpose, value);
 }
 
@@ -3173,7 +3173,7 @@ void CallLogWrapper::glProgramUniformMatrix2x4fv (glw::GLuint program, glw::GLin
 void CallLogWrapper::glProgramUniformMatrix3dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniformMatrix3dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniformMatrix3dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniformMatrix3dv(program, location, count, transpose, value);
 }
 
@@ -3187,7 +3187,7 @@ void CallLogWrapper::glProgramUniformMatrix3fv (glw::GLuint program, glw::GLint
 void CallLogWrapper::glProgramUniformMatrix3x2dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniformMatrix3x2dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniformMatrix3x2dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniformMatrix3x2dv(program, location, count, transpose, value);
 }
 
@@ -3201,7 +3201,7 @@ void CallLogWrapper::glProgramUniformMatrix3x2fv (glw::GLuint program, glw::GLin
 void CallLogWrapper::glProgramUniformMatrix3x4dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniformMatrix3x4dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniformMatrix3x4dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniformMatrix3x4dv(program, location, count, transpose, value);
 }
 
@@ -3215,7 +3215,7 @@ void CallLogWrapper::glProgramUniformMatrix3x4fv (glw::GLuint program, glw::GLin
 void CallLogWrapper::glProgramUniformMatrix4dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniformMatrix4dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniformMatrix4dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniformMatrix4dv(program, location, count, transpose, value);
 }
 
@@ -3229,7 +3229,7 @@ void CallLogWrapper::glProgramUniformMatrix4fv (glw::GLuint program, glw::GLint
 void CallLogWrapper::glProgramUniformMatrix4x2dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniformMatrix4x2dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniformMatrix4x2dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniformMatrix4x2dv(program, location, count, transpose, value);
 }
 
@@ -3243,7 +3243,7 @@ void CallLogWrapper::glProgramUniformMatrix4x2fv (glw::GLuint program, glw::GLin
 void CallLogWrapper::glProgramUniformMatrix4x3dv (glw::GLuint program, glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glProgramUniformMatrix4x3dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glProgramUniformMatrix4x3dv(" << program << ", " << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.programUniformMatrix4x3dv(program, location, count, transpose, value);
 }
 
@@ -3390,7 +3390,7 @@ void CallLogWrapper::glScissor (glw::GLint x, glw::GLint y, glw::GLsizei width,
 void CallLogWrapper::glScissorArrayv (glw::GLuint first, glw::GLsizei count, const glw::GLint *v)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glScissorArrayv(" << first << ", " << count << ", " << v << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glScissorArrayv(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
        m_gl.scissorArrayv(first, count, v);
 }
 
@@ -3404,21 +3404,21 @@ void CallLogWrapper::glScissorIndexed (glw::GLuint index, glw::GLint left, glw::
 void CallLogWrapper::glScissorIndexedv (glw::GLuint index, const glw::GLint *v)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glScissorIndexedv(" << index << ", " << v << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glScissorIndexedv(" << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
        m_gl.scissorIndexedv(index, v);
 }
 
 void CallLogWrapper::glShaderBinary (glw::GLsizei count, const glw::GLuint *shaders, glw::GLenum binaryformat, const void *binary, glw::GLsizei length)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glShaderBinary(" << count << ", " << shaders << ", " << toHex(binaryformat) << ", " << binary << ", " << length << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glShaderBinary(" << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(shaders))) << ", " << toHex(binaryformat) << ", " << binary << ", " << length << ");" << TestLog::EndMessage;
        m_gl.shaderBinary(count, shaders, binaryformat, binary, length);
 }
 
 void CallLogWrapper::glShaderSource (glw::GLuint shader, glw::GLsizei count, const glw::GLchar *const*string, const glw::GLint *length)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glShaderSource(" << shader << ", " << count << ", " << string << ", " << length << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glShaderSource(" << shader << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(string))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(length))) << ");" << TestLog::EndMessage;
        m_gl.shaderSource(shader, count, string, length);
 }
 
@@ -3642,14 +3642,14 @@ void CallLogWrapper::glTextureBufferRange (glw::GLuint texture, glw::GLenum inte
 void CallLogWrapper::glTextureParameterIiv (glw::GLuint texture, glw::GLenum pname, const glw::GLint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glTextureParameterIiv(" << texture << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glTextureParameterIiv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.textureParameterIiv(texture, pname, params);
 }
 
 void CallLogWrapper::glTextureParameterIuiv (glw::GLuint texture, glw::GLenum pname, const glw::GLuint *params)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glTextureParameterIuiv(" << texture << ", " << toHex(pname) << ", " << params << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glTextureParameterIuiv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(params))) << ");" << TestLog::EndMessage;
        m_gl.textureParameterIuiv(texture, pname, params);
 }
 
@@ -3663,7 +3663,7 @@ void CallLogWrapper::glTextureParameterf (glw::GLuint texture, glw::GLenum pname
 void CallLogWrapper::glTextureParameterfv (glw::GLuint texture, glw::GLenum pname, const glw::GLfloat *param)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glTextureParameterfv(" << texture << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glTextureParameterfv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
        m_gl.textureParameterfv(texture, pname, param);
 }
 
@@ -3677,7 +3677,7 @@ void CallLogWrapper::glTextureParameteri (glw::GLuint texture, glw::GLenum pname
 void CallLogWrapper::glTextureParameteriv (glw::GLuint texture, glw::GLenum pname, const glw::GLint *param)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glTextureParameteriv(" << texture << ", " << toHex(pname) << ", " << param << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glTextureParameteriv(" << texture << ", " << toHex(pname) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(param))) << ");" << TestLog::EndMessage;
        m_gl.textureParameteriv(texture, pname, param);
 }
 
@@ -3761,7 +3761,7 @@ void CallLogWrapper::glTransformFeedbackBufferRange (glw::GLuint xfb, glw::GLuin
 void CallLogWrapper::glTransformFeedbackVaryings (glw::GLuint program, glw::GLsizei count, const glw::GLchar *const*varyings, glw::GLenum bufferMode)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glTransformFeedbackVaryings(" << program << ", " << count << ", " << varyings << ", " << toHex(bufferMode) << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glTransformFeedbackVaryings(" << program << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(varyings))) << ", " << toHex(bufferMode) << ");" << TestLog::EndMessage;
        m_gl.transformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
@@ -3775,7 +3775,7 @@ void CallLogWrapper::glUniform1d (glw::GLint location, glw::GLdouble x)
 void CallLogWrapper::glUniform1dv (glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniform1dv(" << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniform1dv(" << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniform1dv(location, count, value);
 }
 
@@ -3831,7 +3831,7 @@ void CallLogWrapper::glUniform2d (glw::GLint location, glw::GLdouble x, glw::GLd
 void CallLogWrapper::glUniform2dv (glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniform2dv(" << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniform2dv(" << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniform2dv(location, count, value);
 }
 
@@ -3887,7 +3887,7 @@ void CallLogWrapper::glUniform3d (glw::GLint location, glw::GLdouble x, glw::GLd
 void CallLogWrapper::glUniform3dv (glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniform3dv(" << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniform3dv(" << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniform3dv(location, count, value);
 }
 
@@ -3943,7 +3943,7 @@ void CallLogWrapper::glUniform4d (glw::GLint location, glw::GLdouble x, glw::GLd
 void CallLogWrapper::glUniform4dv (glw::GLint location, glw::GLsizei count, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniform4dv(" << location << ", " << count << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniform4dv(" << location << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniform4dv(location, count, value);
 }
 
@@ -3999,7 +3999,7 @@ void CallLogWrapper::glUniformBlockBinding (glw::GLuint program, glw::GLuint uni
 void CallLogWrapper::glUniformMatrix2dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniformMatrix2dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniformMatrix2dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniformMatrix2dv(location, count, transpose, value);
 }
 
@@ -4013,7 +4013,7 @@ void CallLogWrapper::glUniformMatrix2fv (glw::GLint location, glw::GLsizei count
 void CallLogWrapper::glUniformMatrix2x3dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniformMatrix2x3dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniformMatrix2x3dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniformMatrix2x3dv(location, count, transpose, value);
 }
 
@@ -4027,7 +4027,7 @@ void CallLogWrapper::glUniformMatrix2x3fv (glw::GLint location, glw::GLsizei cou
 void CallLogWrapper::glUniformMatrix2x4dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniformMatrix2x4dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniformMatrix2x4dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniformMatrix2x4dv(location, count, transpose, value);
 }
 
@@ -4041,7 +4041,7 @@ void CallLogWrapper::glUniformMatrix2x4fv (glw::GLint location, glw::GLsizei cou
 void CallLogWrapper::glUniformMatrix3dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniformMatrix3dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniformMatrix3dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniformMatrix3dv(location, count, transpose, value);
 }
 
@@ -4055,7 +4055,7 @@ void CallLogWrapper::glUniformMatrix3fv (glw::GLint location, glw::GLsizei count
 void CallLogWrapper::glUniformMatrix3x2dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniformMatrix3x2dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniformMatrix3x2dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniformMatrix3x2dv(location, count, transpose, value);
 }
 
@@ -4069,7 +4069,7 @@ void CallLogWrapper::glUniformMatrix3x2fv (glw::GLint location, glw::GLsizei cou
 void CallLogWrapper::glUniformMatrix3x4dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniformMatrix3x4dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniformMatrix3x4dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniformMatrix3x4dv(location, count, transpose, value);
 }
 
@@ -4083,7 +4083,7 @@ void CallLogWrapper::glUniformMatrix3x4fv (glw::GLint location, glw::GLsizei cou
 void CallLogWrapper::glUniformMatrix4dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniformMatrix4dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniformMatrix4dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniformMatrix4dv(location, count, transpose, value);
 }
 
@@ -4097,7 +4097,7 @@ void CallLogWrapper::glUniformMatrix4fv (glw::GLint location, glw::GLsizei count
 void CallLogWrapper::glUniformMatrix4x2dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniformMatrix4x2dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniformMatrix4x2dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniformMatrix4x2dv(location, count, transpose, value);
 }
 
@@ -4111,7 +4111,7 @@ void CallLogWrapper::glUniformMatrix4x2fv (glw::GLint location, glw::GLsizei cou
 void CallLogWrapper::glUniformMatrix4x3dv (glw::GLint location, glw::GLsizei count, glw::GLboolean transpose, const glw::GLdouble *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniformMatrix4x3dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniformMatrix4x3dv(" << location << ", " << count << ", " << getBooleanStr(transpose) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.uniformMatrix4x3dv(location, count, transpose, value);
 }
 
@@ -4125,7 +4125,7 @@ void CallLogWrapper::glUniformMatrix4x3fv (glw::GLint location, glw::GLsizei cou
 void CallLogWrapper::glUniformSubroutinesuiv (glw::GLenum shadertype, glw::GLsizei count, const glw::GLuint *indices)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glUniformSubroutinesuiv(" << toHex(shadertype) << ", " << count << ", " << indices << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glUniformSubroutinesuiv(" << toHex(shadertype) << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(indices))) << ");" << TestLog::EndMessage;
        m_gl.uniformSubroutinesuiv(shadertype, count, indices);
 }
 
@@ -4229,7 +4229,7 @@ void CallLogWrapper::glVertexArrayVertexBuffer (glw::GLuint vaobj, glw::GLuint b
 void CallLogWrapper::glVertexArrayVertexBuffers (glw::GLuint vaobj, glw::GLuint first, glw::GLsizei count, const glw::GLuint *buffers, const glw::GLintptr *offsets, const glw::GLsizei *strides)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glVertexArrayVertexBuffers(" << vaobj << ", " << first << ", " << count << ", " << buffers << ", " << offsets << ", " << strides << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glVertexArrayVertexBuffers(" << vaobj << ", " << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(buffers))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(offsets))) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(strides))) << ");" << TestLog::EndMessage;
        m_gl.vertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
 }
 
@@ -4670,7 +4670,7 @@ void CallLogWrapper::glVertexAttribL1d (glw::GLuint index, glw::GLdouble x)
 void CallLogWrapper::glVertexAttribL1dv (glw::GLuint index, const glw::GLdouble *v)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glVertexAttribL1dv(" << index << ", " << v << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glVertexAttribL1dv(" << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
        m_gl.vertexAttribL1dv(index, v);
 }
 
@@ -4684,7 +4684,7 @@ void CallLogWrapper::glVertexAttribL2d (glw::GLuint index, glw::GLdouble x, glw:
 void CallLogWrapper::glVertexAttribL2dv (glw::GLuint index, const glw::GLdouble *v)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glVertexAttribL2dv(" << index << ", " << v << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glVertexAttribL2dv(" << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
        m_gl.vertexAttribL2dv(index, v);
 }
 
@@ -4698,7 +4698,7 @@ void CallLogWrapper::glVertexAttribL3d (glw::GLuint index, glw::GLdouble x, glw:
 void CallLogWrapper::glVertexAttribL3dv (glw::GLuint index, const glw::GLdouble *v)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glVertexAttribL3dv(" << index << ", " << v << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glVertexAttribL3dv(" << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
        m_gl.vertexAttribL3dv(index, v);
 }
 
@@ -4712,7 +4712,7 @@ void CallLogWrapper::glVertexAttribL4d (glw::GLuint index, glw::GLdouble x, glw:
 void CallLogWrapper::glVertexAttribL4dv (glw::GLuint index, const glw::GLdouble *v)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glVertexAttribL4dv(" << index << ", " << v << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glVertexAttribL4dv(" << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
        m_gl.vertexAttribL4dv(index, v);
 }
 
@@ -4740,7 +4740,7 @@ void CallLogWrapper::glVertexAttribP1ui (glw::GLuint index, glw::GLenum type, gl
 void CallLogWrapper::glVertexAttribP1uiv (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, const glw::GLuint *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glVertexAttribP1uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glVertexAttribP1uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.vertexAttribP1uiv(index, type, normalized, value);
 }
 
@@ -4754,7 +4754,7 @@ void CallLogWrapper::glVertexAttribP2ui (glw::GLuint index, glw::GLenum type, gl
 void CallLogWrapper::glVertexAttribP2uiv (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, const glw::GLuint *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glVertexAttribP2uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glVertexAttribP2uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.vertexAttribP2uiv(index, type, normalized, value);
 }
 
@@ -4768,7 +4768,7 @@ void CallLogWrapper::glVertexAttribP3ui (glw::GLuint index, glw::GLenum type, gl
 void CallLogWrapper::glVertexAttribP3uiv (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, const glw::GLuint *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glVertexAttribP3uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glVertexAttribP3uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.vertexAttribP3uiv(index, type, normalized, value);
 }
 
@@ -4782,7 +4782,7 @@ void CallLogWrapper::glVertexAttribP4ui (glw::GLuint index, glw::GLenum type, gl
 void CallLogWrapper::glVertexAttribP4uiv (glw::GLuint index, glw::GLenum type, glw::GLboolean normalized, const glw::GLuint *value)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glVertexAttribP4uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << value << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glVertexAttribP4uiv(" << index << ", " << toHex(type) << ", " << getBooleanStr(normalized) << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(value))) << ");" << TestLog::EndMessage;
        m_gl.vertexAttribP4uiv(index, type, normalized, value);
 }
 
@@ -4810,7 +4810,7 @@ void CallLogWrapper::glViewport (glw::GLint x, glw::GLint y, glw::GLsizei width,
 void CallLogWrapper::glViewportArrayv (glw::GLuint first, glw::GLsizei count, const glw::GLfloat *v)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glViewportArrayv(" << first << ", " << count << ", " << v << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glViewportArrayv(" << first << ", " << count << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
        m_gl.viewportArrayv(first, count, v);
 }
 
@@ -4824,7 +4824,7 @@ void CallLogWrapper::glViewportIndexedf (glw::GLuint index, glw::GLfloat x, glw:
 void CallLogWrapper::glViewportIndexedfv (glw::GLuint index, const glw::GLfloat *v)
 {
        if (m_enableLog)
-               m_log << TestLog::Message << "glViewportIndexedfv(" << index << ", " << v << ");" << TestLog::EndMessage;
+               m_log << TestLog::Message << "glViewportIndexedfv(" << index << ", " << toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(v))) << ");" << TestLog::EndMessage;
        m_gl.viewportIndexedfv(index, v);
 }
 

diff --git a/scripts/opengl/gen_call_log_wrapper.py b/scripts/opengl/gen_call_log_wrapper.py
index 84bf266..731251a 100644 (file)
--- a/scripts/opengl/gen_call_log_wrapper.py
+++ b/scripts/opengl/gen_call_log_wrapper.py
@@ -45,10 +45,10 @@ def textureUnit (name):
        return "getTextureUnitStr(%s)" % name
 
 def voidPointer (name):
-       return "static_cast<const void*>(%s)" % name
+       return "toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(%s)))" % name
 
 def fnPointer (name):
-       return "((const void*)(%s))" % name
+       return "toHex(reinterpret_cast<deUintptr>(%s))" % name
 
 stringVal = lambda name: "getStringStr(%s)" % name
 
@@ -186,8 +186,8 @@ CALL_LOG_SPECS = {
        "glGetShaderInfoLog":                                   LogSpec({3: voidPointer}, argOutPrints = {2: pointer(size = "1")}),
        "glGetShaderPrecisionFormat":                   LogSpec({0: enum("ShaderType"), 1: enum("PrecisionFormatType")}),
 #      "glGetShaderSource":
-       "glGetString":                                                  LogSpec({0: enum("GettableString")}),
-       "glGetStringi":                                                 LogSpec({0: enum("GettableString")}),
+       "glGetString":                                                  LogSpec({0: enum("GettableString")}, returnPrint=stringVal),
+       "glGetStringi":                                                 LogSpec({0: enum("GettableString")}, returnPrint=stringVal),
        "glGetTexParameterfv":                                  LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "1")}),
        "glGetTexParameteriv":                                  LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "1")}),
        "glGetTexParameterIiv":                                 LogSpec({0: enum("TextureTarget"), 1: enum("TextureParameter")}, argOutPrints = {2: pointer(size = "getTextureParamQueryNumArgsOut(pname)")}),
@@ -351,10 +351,10 @@ CALL_LOG_SPECS = {
        "glTexBufferRange":                                             LogSpec({0: enum("BufferTarget"), 1: enum("PixelFormat")}),
 }
 
-def glwPrefix(string):
+def glwPrefix (string):
        return re.sub(r'\bGL', 'glw::GL', string)
 
-def prefixedParams(command):
+def prefixedParams (command):
        if len(command.params) > 0:
                return ", ".join(glwPrefix(param.declaration) for param in command.params)
        else:
@@ -364,12 +364,17 @@ def commandLogWrapperMemberDecl (command):
        return "%s\t%s\t(%s);" % (glwPrefix(command.type), command.name, prefixedParams(command))
 
 def getVarDefaultPrint (type, varName):
-       if re.match(r'^const +(GLchar|GLubyte) *\*$', type):
+       if re.match(r'^const +GLchar *\*$', type):
                return "getStringStr(%s)" % varName
        elif re.match(r'(GLubyte|GLbyte|GLenum|GLushort|GLbitfield|\*)$', type):
                return "toHex(%s)" % varName
        elif type == 'GLboolean':
                return "getBooleanStr(%s)" % varName
+       elif re.match(r'^(const +)?.+ *\*$', type) and not re.match(r'^(const +)?void *\*$', type):
+               # non-void pointer type, always cast to void* to avoid unforeseen consequences of
+               # implicit assumptions (such as char* should be printed as a zero-terminated string)
+               # \note use static_cast to break the build if function pointer is supplied
+               return "toHex(reinterpret_cast<deUintptr>(static_cast<const void*>(%s)))" % varName
        else:
                return varName