util/gl: Kill shader wrapper functions

This patch kills the wrapper functions defined in piglit-shader.h for GL.
They are rendered obsolete by piglit-dispatch.

A subset of the wrappers are kept for GLES1 and GLES2.

    - All GLES1 wrappers are kept and are renamed to match the core GL
      names.  That is, piglit_$func is renamed to gl$func. As before, the
      wrappers simply raise an assertion failure because GLES1 does not
      suppport shaders.

    - The subset of GLES2 wrappers that raise an assertion, because the
      function is not supported on GLES2,  are also kept and likewise
      renamed.

Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
Reviewed-by: Anuj Phogat <anuj.phogat@gmail.com>

61 files changed, 475 insertions, 741 deletions

diff --git a/tests/fbo/fbo-depth-sample-compare.c b/tests/fbo/fbo-depth-sample-compare.c
index 11dadffe..1e925bb7 100644
--- a/tests/fbo/fbo-depth-sample-compare.c
+++ b/tests/fbo/fbo-depth-sample-compare.c
@@ -168,18 +168,18 @@ create_frag_shader(void)
    ShaderProg = piglit_link_simple_program(0, fs);
    assert(ShaderProg);
 
-   piglit_UseProgram(ShaderProg);
+   glUseProgram(ShaderProg);
 
-   zTex = piglit_GetUniformLocation(ShaderProg, "zTex");
-   piglit_Uniform1i(zTex, 0);  /* unit 0 */
+   zTex = glGetUniformLocation(ShaderProg, "zTex");
+   glUniform1i(zTex, 0);  /* unit 0 */
 
-   errorScale = piglit_GetUniformLocation(ShaderProg, "errorScale");
-   piglit_Uniform1f(errorScale, ErrorScale);
+   errorScale = glGetUniformLocation(ShaderProg, "errorScale");
+   glUniform1f(errorScale, ErrorScale);
 
-   sizeScale = piglit_GetUniformLocation(ShaderProg, "sizeScale");
-   piglit_Uniform1f(sizeScale, (float) (SIZE - 1));
+   sizeScale = glGetUniformLocation(ShaderProg, "sizeScale");
+   glUniform1f(sizeScale, (float) (SIZE - 1));
 
-   piglit_UseProgram(0);
+   glUseProgram(0);
 }
 
 
@@ -394,7 +394,7 @@ draw_sphere_with_fragment_shader_compare(void)
 
    glBindTexture(TexTarget, DepthTex);
 
-   piglit_UseProgram(ShaderProg);
+   glUseProgram(ShaderProg);
 
    glEnable(GL_DEPTH_TEST);
 
@@ -422,7 +422,7 @@ draw_sphere_with_fragment_shader_compare(void)
 
    glDisable(GL_DEPTH_TEST);
 
-   piglit_UseProgram(0);
+   glUseProgram(0);
 
 #if DEBUG
    {
diff --git a/tests/fbo/fbo-gl_pointcoord.c b/tests/fbo/fbo-gl_pointcoord.c
index f416fe87..05411b69 100644
--- a/tests/fbo/fbo-gl_pointcoord.c
+++ b/tests/fbo/fbo-gl_pointcoord.c
@@ -123,7 +123,7 @@ piglit_init(int argc, char **argv)
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text);
 	prog = piglit_link_simple_program(vs, fs);
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
 	glGenRenderbuffers(1, &rb);
 	glBindRenderbuffer(GL_RENDERBUFFER, rb);
diff --git a/tests/general/attribs.c b/tests/general/attribs.c
index 7e8fc138..a94843fc 100644
--- a/tests/general/attribs.c
+++ b/tests/general/attribs.c
@@ -150,7 +150,7 @@ static GLboolean test(int x, int y, const char *shaderfunc,
 		piglit_report_result(PIGLIT_FAIL);
 
 	/* Render. */
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 	glLoadIdentity();
 	glTranslatef(x, y, 0);
 
diff --git a/tests/general/getactiveattrib.c b/tests/general/getactiveattrib.c
index 7cadf6e4..a1075b1d 100644
--- a/tests/general/getactiveattrib.c
+++ b/tests/general/getactiveattrib.c
@@ -456,7 +456,7 @@ do_test(const struct test *tests, unsigned num_tests)
 		 * Compare the set of active attributes against the list of
 		 * expected active attributes.
 		 */
-		piglit_GetProgramiv(prog, GL_ACTIVE_ATTRIBUTES, &num_attr);
+		glGetProgramiv(prog, GL_ACTIVE_ATTRIBUTES, &num_attr);
 
 		for (j = 0; j < num_attr; j++) {
 			const struct attribute *attr;
diff --git a/tests/general/pos-array.c b/tests/general/pos-array.c
index a1bb969d..70c3909f 100644
--- a/tests/general/pos-array.c
+++ b/tests/general/pos-array.c
@@ -204,14 +204,14 @@ test_glsl_arrays(void)
    fragShader = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fragShaderText);
    program = piglit_link_simple_program(vertShader, fragShader);
 
-   piglit_UseProgram(program);
+   glUseProgram(program);
 
    /*
     * Draw with compiler-assigned attribute locations
     */
    {
-      posAttrib = piglit_GetAttribLocation(program, "pos");
-      colorAttrib = piglit_GetAttribLocation(program, "color");
+      posAttrib = glGetAttribLocation(program, "pos");
+      colorAttrib = glGetAttribLocation(program, "color");
 
       if (0)
          printf("%s: GLSL posAttrib = %d  colorAttrib = %d\n",
@@ -247,10 +247,10 @@ test_glsl_arrays(void)
       posAttrib = 5;
       colorAttrib = 7;
 
-      piglit_BindAttribLocation(program, posAttrib, "pos");
-      piglit_BindAttribLocation(program, colorAttrib, "color");
+      glBindAttribLocation(program, posAttrib, "pos");
+      glBindAttribLocation(program, colorAttrib, "color");
 
-      piglit_LinkProgram(program);
+      glLinkProgram(program);
 
       glVertexAttribPointerARB(posAttrib, 2, GL_FLOAT, GL_FALSE,
                                2 * sizeof(GLfloat), (void *) 0);
@@ -275,8 +275,8 @@ test_glsl_arrays(void)
       glDisableVertexAttribArrayARB(colorAttrib);
    }
 
-   piglit_DeleteShader(vertShader);
-   piglit_DeleteProgram(program);
+   glDeleteShader(vertShader);
+   glDeleteProgram(program);
    glDeleteBuffersARB(1, &buf);
 
    return pass;
@@ -314,7 +314,7 @@ test_glsl_no_arrays(void)
    fragShader = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fragShaderText);
    program = piglit_link_simple_program(vertShader, fragShader);
 
-   piglit_UseProgram(program);
+   glUseProgram(program);
 
    glClear(GL_COLOR_BUFFER_BIT);
    glPointSize(3.0);
@@ -329,8 +329,8 @@ test_glsl_no_arrays(void)
       pass = GL_FALSE;
    }
 
-   piglit_DeleteShader(vertShader);
-   piglit_DeleteProgram(program);
+   glDeleteShader(vertShader);
+   glDeleteProgram(program);
 
    return pass;
 }
diff --git a/tests/glslparsertest/glslparsertest.c b/tests/glslparsertest/glslparsertest.c
index 6a2ee9a7..ff32da79 100644
--- a/tests/glslparsertest/glslparsertest.c
+++ b/tests/glslparsertest/glslparsertest.c
@@ -161,7 +161,7 @@ attach_complementary_shader(GLuint shader_prog, GLenum type)
 		piglit_report_result(PIGLIT_FAIL);
 		exit(1);
 	}
-	piglit_AttachShader(shader_prog, shader);
+	glAttachShader(shader_prog, shader);
 }
 
 static void
@@ -198,15 +198,15 @@ test(void)
 		exit(1);
 	}
 
-	prog = piglit_CreateShader(type);
-	piglit_ShaderSource(prog, 1, (const GLchar **)&prog_string, NULL);
-	piglit_CompileShader(prog);
+	prog = glCreateShader(type);
+	glShaderSource(prog, 1, (const GLchar **)&prog_string, NULL);
+	glCompileShader(prog);
 	ok = get_shader_compile_status(prog);
 
 	size = get_shader_info_log_length(prog);
 	if (size != 0) {
 		info = malloc(size);
-		piglit_GetShaderInfoLog(prog, size, NULL, info);
+		glGetShaderInfoLog(prog, size, NULL, info);
 	} else {
 		info = "(no compiler output)";
 	}
@@ -220,18 +220,18 @@ test(void)
 		 */
 		GLuint shader_prog;
 
-		shader_prog = piglit_CreateProgram();
-		piglit_AttachShader(shader_prog, prog);
+		shader_prog = glCreateProgram();
+		glAttachShader(shader_prog, prog);
 		if (requested_version == 100)
 			attach_complementary_shader(shader_prog, type);
-		piglit_LinkProgram(shader_prog);
+		glLinkProgram(shader_prog);
 		if (check_link) {
 			ok = piglit_link_check_status_quiet(shader_prog);
 			if (!ok) {
 				failing_stage = "link";
 			}
 		}
-		piglit_DeleteProgram(shader_prog);
+		glDeleteProgram(shader_prog);
 	}
 
 	pass = (expected_pass == ok);
@@ -264,7 +264,7 @@ test(void)
 	if (size != 0)
 		free(info);
 	free(prog_string);
-	piglit_DeleteShader(prog);
+	glDeleteShader(prog);
 	piglit_report_result (pass ? PIGLIT_PASS : PIGLIT_FAIL);
 }
 
diff --git a/tests/shaders/attribute0.c b/tests/shaders/attribute0.c
index e77fabc0..0d50d17b 100644
--- a/tests/shaders/attribute0.c
+++ b/tests/shaders/attribute0.c
@@ -85,11 +85,11 @@ piglit_init(int argc, char **argv)
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_text);
 	prog = piglit_link_simple_program(vs, fs);
 
-	piglit_BindAttribLocation(prog, 0, "vertex");
-	piglit_LinkProgram(prog);
+	glBindAttribLocation(prog, 0, "vertex");
+	glLinkProgram(prog);
 	piglit_link_check_status(prog);
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
 	glClearColor(blue[0], blue[1], blue[2], blue[3]);
 }
diff --git a/tests/shaders/getuniform-01.c b/tests/shaders/getuniform-01.c
index b32a829a..016a6d07 100644
--- a/tests/shaders/getuniform-01.c
+++ b/tests/shaders/getuniform-01.c
@@ -115,9 +115,9 @@ piglit_init(int argc, char **argv)
 
 	prog = piglit_link_simple_program(vs, fs);
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
-	base_location = piglit_GetUniformLocation(prog, "c");
+	base_location = glGetUniformLocation(prog, "c");
 	if (base_location < 0) {
 		printf("Could not get location of `c'.\n");
 		piglit_report_result(PIGLIT_FAIL);
@@ -131,7 +131,7 @@ piglit_init(int argc, char **argv)
 		name[2] = '0' + i;
 		name[3] = ']';
 		name[4] = '\0';
-		array_location[i] = piglit_GetUniformLocation(prog, name);
+		array_location[i] = glGetUniformLocation(prog, name);
 		if (array_location[i] < 0) {
 			printf("Could not get location of `%s'.\n", name);
 			piglit_report_result(PIGLIT_FAIL);
@@ -154,7 +154,7 @@ piglit_init(int argc, char **argv)
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
-	piglit_Uniform1fv(base_location, 4, uniform_data);
+	glUniform1fv(base_location, 4, uniform_data);
 
 	/* From page 264 of the OpenGL 2.1 spec:
 	 *
@@ -169,7 +169,7 @@ piglit_init(int argc, char **argv)
 		buffer[i].u = 0xdeadbeef;
 	}
 
-	piglit_GetUniformfv(prog, base_location, (GLfloat *) buffer);
+	glGetUniformfv(prog, base_location, (GLfloat *) buffer);
 	validate_buffer(buffer, ARRAY_SIZE(buffer), uniform_data[0]);
 
 	printf("Getting one array element at a time...\n");
@@ -179,7 +179,7 @@ piglit_init(int argc, char **argv)
 			buffer[j].u = 0xdeadbeef;
 		}
 
-		piglit_GetUniformfv(prog, array_location[i],
+		glGetUniformfv(prog, array_location[i],
 				    (GLfloat *) buffer);
 		validate_buffer(buffer, ARRAY_SIZE(buffer), uniform_data[i]);
 	}
diff --git a/tests/shaders/getuniform-02.c b/tests/shaders/getuniform-02.c
index c744f1d0..5d774038 100644
--- a/tests/shaders/getuniform-02.c
+++ b/tests/shaders/getuniform-02.c
@@ -79,9 +79,9 @@ piglit_init(int argc, char **argv)
    vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_text);
    prog = piglit_link_simple_program(vs, 0);
 
-   piglit_UseProgram(prog);
+   glUseProgram(prog);
 
-   piglit_GetProgramiv(prog, GL_ACTIVE_UNIFORMS, &numUniforms);
+   glGetProgramiv(prog, GL_ACTIVE_UNIFORMS, &numUniforms);
    if (numUniforms != expectedNum) {
       printf("%s: incorrect number of uniforms (found %d, expected %d)\n",
              TestName, numUniforms, expectedNum);
@@ -96,9 +96,9 @@ piglit_init(int argc, char **argv)
       GLenum type, expectedType;
       GLint loc;
 
-      piglit_GetActiveUniform(prog,
+      glGetActiveUniform(prog,
 				 i, sizeof(name), &len, &size, &type, name);
-      loc = piglit_GetUniformLocation(prog, name);
+      loc = glGetUniformLocation(prog, name);
 
       if (loc < 0) {
          printf("%s: bad uniform location for %s: %d\n", TestName, name, loc);
@@ -133,47 +133,47 @@ piglit_init(int argc, char **argv)
 
    /* Check setting/getting values */
 
-   loc_f1 = piglit_GetUniformLocation(prog, "f1");
-   loc_f2 = piglit_GetUniformLocation(prog, "f2");
-   loc_sa = piglit_GetUniformLocation(prog, "s.a");
-   loc_sd = piglit_GetUniformLocation(prog, "s.d");
-   loc_v1 = piglit_GetUniformLocation(prog, "v[1]");
+   loc_f1 = glGetUniformLocation(prog, "f1");
+   loc_f2 = glGetUniformLocation(prog, "f2");
+   loc_sa = glGetUniformLocation(prog, "s.a");
+   loc_sd = glGetUniformLocation(prog, "s.d");
+   loc_v1 = glGetUniformLocation(prog, "v[1]");
 
-   piglit_Uniform1f(loc_f1, 5.0);
-   piglit_Uniform1f(loc_f2, 10.0);
-   piglit_Uniform1f(loc_sa, 15.0);
-   piglit_Uniform1f(loc_sd, 20.0);
-   piglit_Uniform4fv(loc_v1, 1, vVals);
+   glUniform1f(loc_f1, 5.0);
+   glUniform1f(loc_f2, 10.0);
+   glUniform1f(loc_sa, 15.0);
+   glUniform1f(loc_sd, 20.0);
+   glUniform4fv(loc_v1, 1, vVals);
 
-   piglit_GetUniformfv(prog, loc_f1, v);
+   glGetUniformfv(prog, loc_f1, v);
    if (v[0] != 5.0) {
       printf("%s: wrong value for f1 (found %f, expected %f)\n",
              TestName, v[0], 5.0);
       piglit_report_result(PIGLIT_FAIL);
    }
 
-   piglit_GetUniformfv(prog, loc_f2, v);
+   glGetUniformfv(prog, loc_f2, v);
    if (v[0] != 10.0) {
       printf("%s: wrong value for f2 (found %f, expected %f)\n",
              TestName, v[0], 10.0);
       piglit_report_result(PIGLIT_FAIL);
    }
 
-   piglit_GetUniformfv(prog, loc_sa, v);
+   glGetUniformfv(prog, loc_sa, v);
    if (v[0] != 15.0) {
       printf("%s: wrong value for s.a (found %f, expected %f)\n",
              TestName, v[0], 15.0);
       piglit_report_result(PIGLIT_FAIL);
    }
 
-   piglit_GetUniformfv(prog, loc_sd, v);
+   glGetUniformfv(prog, loc_sd, v);
    if (v[0] != 20.0) {
       printf("%s: wrong value for s.d (found %f, expected %f)\n",
              TestName, v[0], 20.0);
       piglit_report_result(PIGLIT_FAIL);
    }
 
-   piglit_GetUniformfv(prog, loc_v1, v);
+   glGetUniformfv(prog, loc_v1, v);
    if (v[0] != 30.0 ||
        v[1] != 31.0 ||
        v[2] != 32.0 ||
diff --git a/tests/shaders/glsl-bindattriblocation.c b/tests/shaders/glsl-bindattriblocation.c
index fd02e8db..c2101302 100644
--- a/tests/shaders/glsl-bindattriblocation.c
+++ b/tests/shaders/glsl-bindattriblocation.c
@@ -86,7 +86,7 @@ piglit_display(void)
 
 	/* Bind "attrib" to location 3 and re-link */
 	glBindAttribLocation(prog, 3, "attrib");
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 
 	/* check that the bind worked */
 	attrib_loc = glGetAttribLocation(prog, "attrib");
@@ -100,7 +100,7 @@ piglit_display(void)
 	}
 
 	/* now draw something and check that it works */
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
diff --git a/tests/shaders/glsl-bug-22603.c b/tests/shaders/glsl-bug-22603.c
index b36f4483..9a686100 100644
--- a/tests/shaders/glsl-bug-22603.c
+++ b/tests/shaders/glsl-bug-22603.c
@@ -98,10 +98,10 @@ piglit_display(void)
 
 	glViewport(0, 0, 512, 512);
 	glClear(GL_DEPTH_BUFFER_BIT);
-	piglit_UseProgram(shadow_prog);
-	piglit_Uniform1i(shadowMap_location, 0);
+	glUseProgram(shadow_prog);
+	glUniform1i(shadowMap_location, 0);
 	/* ogl reads in col-vectors, so transform=true */
-	piglit_UniformMatrix4fv(light_projection_location,
+	glUniformMatrix4fv(light_projection_location,
 			      1, GL_TRUE, matrix);
 	glBegin(GL_QUADS);
 		/* rect1 */
@@ -131,8 +131,8 @@ piglit_display(void)
 	glActiveTextureARB(GL_TEXTURE0_ARB);
 	glBindTexture(GL_TEXTURE_2D, shadow_texture);
 
-	piglit_UseProgram(prog);
-	piglit_UniformMatrix4fv(eye_projection_location, 1, 1, matrix);
+	glUseProgram(prog);
+	glUniformMatrix4fv(eye_projection_location, 1, 1, matrix);
 	/* this is the quad that is texturized with what we want to see */
 	glBegin(GL_QUADS);
 
@@ -210,9 +210,9 @@ piglit_init(int argc, char **argv)
 	shadow_fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_shadow_source);
 	shadow_prog = piglit_link_simple_program(shadow_vs, shadow_fs);
 
-	eye_projection_location = piglit_GetUniformLocation(prog,
+	eye_projection_location = glGetUniformLocation(prog,
 							  "eye_projection");
-	light_projection_location = piglit_GetUniformLocation(shadow_prog,
+	light_projection_location = glGetUniformLocation(shadow_prog,
 							    "light_projection");
-	shadowMap_location = piglit_GetUniformLocation(shadow_prog, "shadowMap");
+	shadowMap_location = glGetUniformLocation(shadow_prog, "shadowMap");
 }
diff --git a/tests/shaders/glsl-fs-color-matrix.c b/tests/shaders/glsl-fs-color-matrix.c
index 312409eb..53f32c0b 100644
--- a/tests/shaders/glsl-fs-color-matrix.c
+++ b/tests/shaders/glsl-fs-color-matrix.c
@@ -137,27 +137,27 @@ piglit_init(int argc, char **argv)
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_text);
 	prog = piglit_link_simple_program(vs, fs);
 
-	piglit_BindAttribLocation(prog, 0, "vertex");
-	piglit_BindAttribLocation(prog, 1, "textureCoord");
+	glBindAttribLocation(prog, 0, "vertex");
+	glBindAttribLocation(prog, 1, "textureCoord");
 
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	piglit_link_check_status(prog);
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
-	loc = piglit_GetUniformLocation(prog, "colorMatrix");
-	piglit_UniformMatrix4fv(loc, 1, GL_FALSE, identity_matrix);
+	loc = glGetUniformLocation(prog, "colorMatrix");
+	glUniformMatrix4fv(loc, 1, GL_FALSE, identity_matrix);
 
-	loc = piglit_GetUniformLocation(prog, "texture");
-	piglit_Uniform1i(loc, 0);
+	loc = glGetUniformLocation(prog, "texture");
+	glUniform1i(loc, 0);
 
 	glClearColor(0.2, 0.2, 0.2, 1.0);
 
-	piglit_VertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE,
+	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE,
 				   2 * sizeof(GLfloat), vertex);
-	piglit_VertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,
+	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE,
 				   2 * sizeof(GLfloat), tex_coord);
 
-	piglit_EnableVertexAttribArray(0);
-	piglit_EnableVertexAttribArray(1);
+	glEnableVertexAttribArray(0);
+	glEnableVertexAttribArray(1);
 }
diff --git a/tests/shaders/glsl-fs-discard-02.c b/tests/shaders/glsl-fs-discard-02.c
index 166285f4..b4afbbac 100644
--- a/tests/shaders/glsl-fs-discard-02.c
+++ b/tests/shaders/glsl-fs-discard-02.c
@@ -74,7 +74,7 @@ static GLuint setup_shaders()
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_code);
 	prog = piglit_link_simple_program(vs, fs);
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 	return prog;
 }
 
@@ -99,7 +99,7 @@ static GLboolean test()
 
 	pass = pass && piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, green);
 
-	piglit_DeleteProgram(prog);
+	glDeleteProgram(prog);
 
 	return pass;
 }
diff --git a/tests/shaders/glsl-getactiveuniform-count.c b/tests/shaders/glsl-getactiveuniform-count.c
index 1ea1646e..6e888e1b 100644
--- a/tests/shaders/glsl-getactiveuniform-count.c
+++ b/tests/shaders/glsl-getactiveuniform-count.c
@@ -72,7 +72,7 @@ piglit_init(int argc, char **argv)
 
 	prog = piglit_link_simple_program(vs, fs);
 
-	piglit_GetProgramiv(prog, GL_ACTIVE_UNIFORMS, &num);
+	glGetProgramiv(prog, GL_ACTIVE_UNIFORMS, &num);
 	if (num != expect) {
 		printf("Unexpected active uniform count "
 		       "(saw %d, expected %d)\n", num, expect);
diff --git a/tests/shaders/glsl-link-test.c b/tests/shaders/glsl-link-test.c
index dd33391f..6b5c2f9a 100644
--- a/tests/shaders/glsl-link-test.c
+++ b/tests/shaders/glsl-link-test.c
@@ -55,7 +55,7 @@ void piglit_init(int argc, char **argv)
 	piglit_require_gl_version(20);
 
 	piglit_require_GLSL();
-	program = piglit_CreateProgram();
+	program = glCreateProgram();
 
 	for (i = 1; i < argc; i++) {
 		size_t len;
@@ -117,7 +117,7 @@ void piglit_init(int argc, char **argv)
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
-	piglit_LinkProgram(program);
+	glLinkProgram(program);
 
 	result = piglit_link_check_status_quiet(program);
 	if (result != expect)
diff --git a/tests/shaders/shader_runner.c b/tests/shaders/shader_runner.c
index d07ba165..e4752cee 100644
--- a/tests/shaders/shader_runner.c
+++ b/tests/shaders/shader_runner.c
@@ -118,7 +118,7 @@ string_match(const char *string, const char *line)
 void
 compile_glsl(GLenum target, bool release_text)
 {
-	GLuint shader = piglit_CreateShader(target);
+	GLuint shader = glCreateShader(target);
 	GLint ok;
 
 	switch (target) {
@@ -147,28 +147,28 @@ compile_glsl(GLenum target, bool release_text)
 		shader_strings[1] = shader_string;
 		shader_string_sizes[1] = shader_string_size;
 		
-		piglit_ShaderSource(shader, 2,
+		glShaderSource(shader, 2,
 				    (const GLchar **) shader_strings,
 				    shader_string_sizes);
 
 	} else {
-		piglit_ShaderSource(shader, 1,
+		glShaderSource(shader, 1,
 				    (const GLchar **) &shader_string,
 				    &shader_string_size);
 	}
 
-	piglit_CompileShader(shader);
+	glCompileShader(shader);
 
-	piglit_GetShaderiv(shader, GL_COMPILE_STATUS, &ok);
+	glGetShaderiv(shader, GL_COMPILE_STATUS, &ok);
 
 	if (!ok) {
 		GLchar *info;
 		GLint size;
 
-		piglit_GetShaderiv(shader, GL_INFO_LOG_LENGTH, &size);
+		glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &size);
 		info = malloc(size);
 
-		piglit_GetShaderInfoLog(shader, size, NULL, info);
+		glGetShaderInfoLog(shader, size, NULL, info);
 
 		fprintf(stderr, "Failed to compile %s: %s\n",
 			target == GL_FRAGMENT_SHADER ? "FS" : "VS",
@@ -592,43 +592,43 @@ link_and_use_shaders(void)
 	    && (num_geometry_shaders == 0))
 		return;
 
-	prog = piglit_CreateProgram();
+	prog = glCreateProgram();
 
 	for (i = 0; i < num_vertex_shaders; i++) {
-		piglit_AttachShader(prog, vertex_shaders[i]);
+		glAttachShader(prog, vertex_shaders[i]);
 	}
 
 	for (i = 0; i < num_geometry_shaders; i++) {
-		piglit_AttachShader(prog, geometry_shaders[i]);
+		glAttachShader(prog, geometry_shaders[i]);
 	}
 
 	for (i = 0; i < num_fragment_shaders; i++) {
-		piglit_AttachShader(prog, fragment_shaders[i]);
+		glAttachShader(prog, fragment_shaders[i]);
 	}
 
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 
 	for (i = 0; i < num_vertex_shaders; i++) {
-		piglit_DeleteShader(vertex_shaders[i]);
+		glDeleteShader(vertex_shaders[i]);
 	}
 
 	for (i = 0; i < num_geometry_shaders; i++) {
-		piglit_DeleteShader(geometry_shaders[i]);
+		glDeleteShader(geometry_shaders[i]);
 	}
 
 	for (i = 0; i < num_fragment_shaders; i++) {
-		piglit_DeleteShader(fragment_shaders[i]);
+		glDeleteShader(fragment_shaders[i]);
 	}
 
-	piglit_GetProgramiv(prog, GL_LINK_STATUS, &ok);
+	glGetProgramiv(prog, GL_LINK_STATUS, &ok);
 	if (!ok) {
 		GLchar *info;
 		GLint size;
 
-		piglit_GetProgramiv(prog, GL_INFO_LOG_LENGTH, &size);
+		glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &size);
 		info = malloc(size);
 
-		piglit_GetProgramInfoLog(prog, size, NULL, info);
+		glGetProgramInfoLog(prog, size, NULL, info);
 
 		fprintf(stderr, "Failed to link:\n%s\n",
 			info);
@@ -637,7 +637,7 @@ link_and_use_shaders(void)
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
 	err = glGetError();
 	if (err) {
@@ -646,10 +646,10 @@ link_and_use_shaders(void)
 
 		printf("GL error after linking program: 0x%04x\n", err);
 
-		piglit_GetProgramiv(prog, GL_INFO_LOG_LENGTH, &size);
+		glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &size);
 		info = malloc(size);
 
-		piglit_GetProgramInfoLog(prog, size, NULL, info);
+		glGetProgramInfoLog(prog, size, NULL, info);
 		fprintf(stderr, "Info log: %s\n", info);
 
 		piglit_report_result(PIGLIT_FAIL);
@@ -1017,7 +1017,7 @@ set_uniform(const char *line)
 	if (set_ubo_uniform(name, type, line))
 		return;
 
-	loc = piglit_GetUniformLocation(prog, name);
+	loc = glGetUniformLocation(prog, name);
 	if (loc < 0) {
 		printf("cannot get location of uniform \"%s\"\n",
 		       name);
@@ -1026,46 +1026,46 @@ set_uniform(const char *line)
 
 	if (string_match("float", type)) {
 		get_floats(line, f, 1);
-		piglit_Uniform1fv(loc, 1, f);
+		glUniform1fv(loc, 1, f);
 		return;
 	} else if (string_match("int", type)) {
 		int val = atoi(line);
-		piglit_Uniform1i(loc, val);
+		glUniform1i(loc, val);
 		return;
 	} else if (string_match("uint", type)) {
 		unsigned val;
 		check_unsigned_support();
 		val = strtoul(line, NULL, 0);
-		piglit_Uniform1ui(loc, val);
+		glUniform1ui(loc, val);
 		return;
 	} else if (string_match("vec", type)) {
 		switch (type[3]) {
 		case '2':
 			get_floats(line, f, 2);
-			piglit_Uniform2fv(loc, 1, f);
+			glUniform2fv(loc, 1, f);
 			return;
 		case '3':
 			get_floats(line, f, 3);
-			piglit_Uniform3fv(loc, 1, f);
+			glUniform3fv(loc, 1, f);
 			return;
 		case '4':
 			get_floats(line, f, 4);
-			piglit_Uniform4fv(loc, 1, f);
+			glUniform4fv(loc, 1, f);
 			return;
 		}
 	} else if (string_match("ivec", type)) {
 		switch (type[4]) {
 		case '2':
 			get_ints(line, ints, 2);
-			piglit_Uniform2iv(loc, 1, ints);
+			glUniform2iv(loc, 1, ints);
 			return;
 		case '3':
 			get_ints(line, ints, 3);
-			piglit_Uniform3iv(loc, 1, ints);
+			glUniform3iv(loc, 1, ints);
 			return;
 		case '4':
 			get_ints(line, ints, 4);
-			piglit_Uniform4iv(loc, 1, ints);
+			glUniform4iv(loc, 1, ints);
 			return;
 		}
 	} else if (string_match("uvec", type)) {
@@ -1073,15 +1073,15 @@ set_uniform(const char *line)
 		switch (type[4]) {
 		case '2':
 			get_uints(line, uints, 2);
-			piglit_Uniform2uiv(loc, 1, uints);
+			glUniform2uiv(loc, 1, uints);
 			return;
 		case '3':
 			get_uints(line, uints, 3);
-			piglit_Uniform3uiv(loc, 1, uints);
+			glUniform3uiv(loc, 1, uints);
 			return;
 		case '4':
 			get_uints(line, uints, 4);
-			piglit_Uniform4uiv(loc, 1, uints);
+			glUniform4uiv(loc, 1, uints);
 			return;
 		}
 	} else if (string_match("mat", type) && type[3] != '\0') {
@@ -1092,45 +1092,45 @@ set_uniform(const char *line)
 			switch (rows) {
 			case '2':
 				get_floats(line, f, 4);
-				piglit_UniformMatrix2fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix2fv(loc, 1, GL_FALSE, f);
 				return;
 			case '3':
 				get_floats(line, f, 6);
-				piglit_UniformMatrix2x3fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix2x3fv(loc, 1, GL_FALSE, f);
 				return;
 			case '4':
 				get_floats(line, f, 8);
-				piglit_UniformMatrix2x4fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix2x4fv(loc, 1, GL_FALSE, f);
 				return;
 			}
 		case '3':
 			switch (rows) {
 			case '2':
 				get_floats(line, f, 6);
-				piglit_UniformMatrix3x2fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix3x2fv(loc, 1, GL_FALSE, f);
 				return;
 			case '3':
 				get_floats(line, f, 9);
-				piglit_UniformMatrix3fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix3fv(loc, 1, GL_FALSE, f);
 				return;
 			case '4':
 				get_floats(line, f, 12);
-				piglit_UniformMatrix3x4fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix3x4fv(loc, 1, GL_FALSE, f);
 				return;
 			}
 		case '4':
 			switch (rows) {
 			case '2':
 				get_floats(line, f, 8);
-				piglit_UniformMatrix4x2fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix4x2fv(loc, 1, GL_FALSE, f);
 				return;
 			case '3':
 				get_floats(line, f, 12);
-				piglit_UniformMatrix4x3fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix4x3fv(loc, 1, GL_FALSE, f);
 				return;
 			case '4':
 				get_floats(line, f, 16);
-				piglit_UniformMatrix4fv(loc, 1, GL_FALSE, f);
+				glUniformMatrix4fv(loc, 1, GL_FALSE, f);
 				return;
 			}
 		}
@@ -1671,8 +1671,8 @@ piglit_display(void)
 
 	if (piglit_automatic) {
 		/* Free our resources, useful for valgrinding. */
-		piglit_DeleteProgram(prog);
-		piglit_UseProgram(0);
+		glDeleteProgram(prog);
+		glUseProgram(0);
 	}
 
 	return pass ? PIGLIT_PASS : PIGLIT_FAIL;
diff --git a/tests/spec/arb_shader_objects/bindattriblocation-scratch-name.c b/tests/spec/arb_shader_objects/bindattriblocation-scratch-name.c
index 789d2457..ec098009 100644
--- a/tests/spec/arb_shader_objects/bindattriblocation-scratch-name.c
+++ b/tests/spec/arb_shader_objects/bindattriblocation-scratch-name.c
@@ -69,8 +69,8 @@ piglit_init(int argc, char **argv)
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
 
 	/* Bind "attrib" to location 3.  Once the attribute is bound, smash
 	 * the string containing the name.  After smashing the name, link the
@@ -78,14 +78,14 @@ piglit_init(int argc, char **argv)
 	 * problems linking.
 	 */
 	memcpy(alt_name, name, sizeof(name));
-	piglit_BindAttribLocation(prog, 3, alt_name);
+	glBindAttribLocation(prog, 3, alt_name);
 	memset(alt_name, 0, sizeof(alt_name));
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 
 	if (!piglit_link_check_status(prog))
 		piglit_report_result(PIGLIT_FAIL);
 
-	attrib_loc = piglit_GetAttribLocation(prog, "attrib");
+	attrib_loc = glGetAttribLocation(prog, "attrib");
 	if (attrib_loc != 3) {
 		fprintf(stderr, "Expected location 3, got location %d\n",
 			attrib_loc);
diff --git a/tests/spec/arb_shader_objects/clear-with-deleted.c b/tests/spec/arb_shader_objects/clear-with-deleted.c
index 7c4ed94e..59d5ed40 100644
--- a/tests/spec/arb_shader_objects/clear-with-deleted.c
+++ b/tests/spec/arb_shader_objects/clear-with-deleted.c
@@ -74,15 +74,15 @@ piglit_display(void)
 	if (!vs || !fs || !prog)
 		piglit_report_result(PIGLIT_FAIL);
 
-	piglit_DeleteShader(vs);
-	piglit_DeleteShader(fs);
-	piglit_UseProgram(prog);
-	piglit_DeleteProgram(prog);
+	glDeleteShader(vs);
+	glDeleteShader(fs);
+	glUseProgram(prog);
+	glDeleteProgram(prog);
 
 	/* Since the program is in use, it should be flagged for
 	 * deletion but not deleted.
 	 */
-	piglit_GetProgramiv(prog, GL_DELETE_STATUS, &status);
+	glGetProgramiv(prog, GL_DELETE_STATUS, &status);
 	if (!piglit_check_gl_error(0))
 		piglit_report_result(PIGLIT_FAIL);
 	if (status != GL_TRUE) {
@@ -108,7 +108,7 @@ piglit_display(void)
 				      green) && pass;
 
 	/* The program should still report being deleted. */
-	piglit_GetProgramiv(prog, GL_DELETE_STATUS, &status);
+	glGetProgramiv(prog, GL_DELETE_STATUS, &status);
 	if (!piglit_check_gl_error(0))
 		piglit_report_result(PIGLIT_FAIL);
 	if (status != GL_TRUE) {
@@ -119,9 +119,9 @@ piglit_display(void)
 	}
 
 	/* Now, disable the program and it should be finally deleted. */
-	piglit_UseProgram(0);
+	glUseProgram(0);
 
-	piglit_GetProgramiv(prog, GL_DELETE_STATUS, &status);
+	glGetProgramiv(prog, GL_DELETE_STATUS, &status);
 	pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
 
 	piglit_present_results();
diff --git a/tests/spec/arb_shader_objects/delete-repeat.c b/tests/spec/arb_shader_objects/delete-repeat.c
index e90f15a5..135db63f 100644
--- a/tests/spec/arb_shader_objects/delete-repeat.c
+++ b/tests/spec/arb_shader_objects/delete-repeat.c
@@ -71,15 +71,15 @@ piglit_display(void)
 	if (!vs || !fs || !prog)
 		piglit_report_result(PIGLIT_FAIL);
 
-	piglit_DeleteShader(vs);
-	piglit_DeleteShader(fs);
-	piglit_UseProgram(prog);
-	piglit_DeleteProgram(prog);
+	glDeleteShader(vs);
+	glDeleteShader(fs);
+	glUseProgram(prog);
+	glDeleteProgram(prog);
 
 	/* Try to blow out the refcount */
-	piglit_DeleteProgram(prog);
-	piglit_DeleteProgram(prog);
-	piglit_DeleteProgram(prog);
+	glDeleteProgram(prog);
+	glDeleteProgram(prog);
+	glDeleteProgram(prog);
 
 	/* Sanity check: deleting didn't already unbind our shader program. */
 	piglit_draw_rect(-1, -1, 2, 2);
@@ -87,7 +87,7 @@ piglit_display(void)
 				      green) && pass;
 
 	/* The program should still report being deleted. */
-	piglit_GetProgramiv(prog, GL_DELETE_STATUS, &status);
+	glGetProgramiv(prog, GL_DELETE_STATUS, &status);
 	if (!piglit_check_gl_error(0))
 		piglit_report_result(PIGLIT_FAIL);
 	if (status != GL_TRUE) {
@@ -98,9 +98,9 @@ piglit_display(void)
 	}
 
 	/* Now, disable the program and it should be finally deleted. */
-	piglit_UseProgram(0);
+	glUseProgram(0);
 
-	piglit_GetProgramiv(prog, GL_DELETE_STATUS, &status);
+	glGetProgramiv(prog, GL_DELETE_STATUS, &status);
 	pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
 
 	piglit_present_results();
diff --git a/tests/spec/arb_shader_objects/getuniform.c b/tests/spec/arb_shader_objects/getuniform.c
index ee3fe79d..d18b39c7 100644
--- a/tests/spec/arb_shader_objects/getuniform.c
+++ b/tests/spec/arb_shader_objects/getuniform.c
@@ -76,16 +76,16 @@ uniformiv_n(int loc, int count, int *values)
 {
 	switch (count) {
 	case 1:
-		piglit_Uniform1iv(loc, 1, values);
+		glUniform1iv(loc, 1, values);
 		break;
 	case 2:
-		piglit_Uniform2iv(loc, 1, values);
+		glUniform2iv(loc, 1, values);
 		break;
 	case 3:
-		piglit_Uniform3iv(loc, 1, values);
+		glUniform3iv(loc, 1, values);
 		break;
 	case 4:
-		piglit_Uniform4iv(loc, 1, values);
+		glUniform4iv(loc, 1, values);
 		break;
 	default:
 		abort();
@@ -97,16 +97,16 @@ uniformfv_n(int loc, int count, float *values)
 {
 	switch (count) {
 	case 1:
-		piglit_Uniform1fv(loc, 1, values);
+		glUniform1fv(loc, 1, values);
 		break;
 	case 2:
-		piglit_Uniform2fv(loc, 1, values);
+		glUniform2fv(loc, 1, values);
 		break;
 	case 3:
-		piglit_Uniform3fv(loc, 1, values);
+		glUniform3fv(loc, 1, values);
 		break;
 	case 4:
-		piglit_Uniform4fv(loc, 1, values);
+		glUniform4fv(loc, 1, values);
 		break;
 	default:
 		abort();
@@ -322,7 +322,7 @@ piglit_init(int argc, char **argv)
 
 	for (i = 0; i < ARRAY_SIZE(uniforms); i++) {
 		const char *name = uniforms[i].name;
-		int loc = piglit_GetUniformLocation(prog, name);
+		int loc = glGetUniformLocation(prog, name);
 		assert(loc != -1);
 
 		pass = pass && uniforms[i].test_func(name, loc,
diff --git a/tests/spec/arb_shader_objects/getuniformlocation-array-of-struct-of-array.c b/tests/spec/arb_shader_objects/getuniformlocation-array-of-struct-of-array.c
index ad11e771..7daacb74 100644
--- a/tests/spec/arb_shader_objects/getuniformlocation-array-of-struct-of-array.c
+++ b/tests/spec/arb_shader_objects/getuniformlocation-array-of-struct-of-array.c
@@ -73,7 +73,7 @@ void piglit_init(int argc, char **argv)
 	 *     "A valid name cannot be a structure, an array of structures, or
 	 *     any portion of a single vector or a matrix."
 	 */
-	loc = piglit_GetUniformLocation(prog, "s");
+	loc = glGetUniformLocation(prog, "s");
 	if (loc != -1) {
 		printf("s location = %d (should be -1)\n", loc);
 		pass = false;
@@ -87,7 +87,7 @@ void piglit_init(int argc, char **argv)
 		 *     matrix."
 		 */
 		snprintf(name, sizeof(name), "s[%d]", i);
-		loc = piglit_GetUniformLocation(prog, name);
+		loc = glGetUniformLocation(prog, name);
 
 		if (loc != -1) {
 			printf("%s location = %d (should be -1)\n", name, loc);
@@ -95,7 +95,7 @@ void piglit_init(int argc, char **argv)
 		}
 
 		snprintf(name, sizeof(name), "s[%d].m", i);
-		loc = piglit_GetUniformLocation(prog, name);
+		loc = glGetUniformLocation(prog, name);
 
 		if (loc == -1) {
 			printf("%s location = %d (should not be -1)\n",
@@ -105,7 +105,7 @@ void piglit_init(int argc, char **argv)
 
 		for (j = 0; j < 10; j++) {
 			snprintf(name, sizeof(name), "s[%d].v[%d]", i, j);
-			loc = piglit_GetUniformLocation(prog, name);
+			loc = glGetUniformLocation(prog, name);
 
 			if (loc == -1) {
 				printf("%s location = %d (should not be -1)\n",
diff --git a/tests/spec/arb_shader_texture_lod/execution/texgrad.c b/tests/spec/arb_shader_texture_lod/execution/texgrad.c
index e502ecd5..bafefe42 100644
--- a/tests/spec/arb_shader_texture_lod/execution/texgrad.c
+++ b/tests/spec/arb_shader_texture_lod/execution/texgrad.c
@@ -175,11 +175,11 @@ enum piglit_result piglit_display(void)
 	glClear(GL_COLOR_BUFFER_BIT);
 
 	glViewport(0, 0, piglit_width/2, piglit_height);
-	piglit_UseProgram(prog_tex);
+	glUseProgram(prog_tex);
 	draw_quad();
 
 	glViewport(piglit_width/2, 0, piglit_width/2, piglit_height);
-	piglit_UseProgram(prog_texgrad);
+	glUseProgram(prog_texgrad);
 	draw_quad();
 
 	if (!piglit_probe_rect_halves_equal_rgba(0, 0, piglit_width, piglit_height))
diff --git a/tests/spec/arb_texture_buffer_object/formats.c b/tests/spec/arb_texture_buffer_object/formats.c
index 05a6e2c8..f0b690ab 100644
--- a/tests/spec/arb_texture_buffer_object/formats.c
+++ b/tests/spec/arb_texture_buffer_object/formats.c
@@ -650,8 +650,8 @@ create_program(struct program *program, const char *type)
 		piglit_report_result(PIGLIT_FAIL);
 
 	program->prog = prog;
-        program->pos_location = piglit_GetUniformLocation(prog, "pos");
-        program->expected_location = piglit_GetUniformLocation(prog,
+        program->pos_location = glGetUniformLocation(prog, "pos");
+        program->expected_location = glGetUniformLocation(prog,
 							       "expected");
 	vertex_location = glGetAttribLocation(prog, "vertex");
 	assert(vertex_location == 0);
diff --git a/tests/spec/arb_texture_cube_map_array/sampler-cube-array-shadow.c b/tests/spec/arb_texture_cube_map_array/sampler-cube-array-shadow.c
index 35818cea..7c80ef63 100644
--- a/tests/spec/arb_texture_cube_map_array/sampler-cube-array-shadow.c
+++ b/tests/spec/arb_texture_cube_map_array/sampler-cube-array-shadow.c
@@ -100,7 +100,7 @@ shaderSetup(void)
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vertShaderText);
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fragShaderText);
 	prog = piglit_link_simple_program(vs, fs);
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 }
 
 
@@ -185,7 +185,7 @@ piglit_display(void)
 	GLfloat black[4] = {0.0, 0.0, 0.0, 1.0};
 
 	loc1 = glGetUniformLocation(prog, "cubeArrayShadow");
-	loc2 = piglit_GetAttribLocation(prog, "compf");
+	loc2 = glGetAttribLocation(prog, "compf");
 	
 	glClear(GL_COLOR_BUFFER_BIT);
 	glMatrixMode(GL_MODELVIEW);
diff --git a/tests/spec/arb_transform_feedback2/draw-auto.c b/tests/spec/arb_transform_feedback2/draw-auto.c
index 16743876..74d78f57 100644
--- a/tests/spec/arb_transform_feedback2/draw-auto.c
+++ b/tests/spec/arb_transform_feedback2/draw-auto.c
@@ -91,13 +91,13 @@ void piglit_init(int argc, char **argv)
 
 	/* Create shaders. */
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
 	glTransformFeedbackVaryingsEXT(prog, sizeof(varyings)/sizeof(varyings[0]),
 				       varyings, GL_INTERLEAVED_ATTRIBS_EXT);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog)) {
-		piglit_DeleteProgram(prog);
+		glDeleteProgram(prog);
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
@@ -142,7 +142,7 @@ enum piglit_result piglit_display(void)
 	glClear(GL_COLOR_BUFFER_BIT);
 
 	/* Render into the TFBO. */
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 	glLoadIdentity();
 
 	glVertexPointer(2, GL_FLOAT, 0, verts);
@@ -168,7 +168,7 @@ enum piglit_result piglit_display(void)
 
 	assert(glGetError() == 0);
 
-	piglit_UseProgram(instanced ? prog_notransform_instanced : prog_notransform);
+	glUseProgram(instanced ? prog_notransform_instanced : prog_notransform);
 	glBindBuffer(GL_ARRAY_BUFFER, buf);
 	glEnableClientState(GL_COLOR_ARRAY);
 	glColorPointer(4, GL_FLOAT, sizeof(float)*8, NULL);
diff --git a/tests/spec/arb_vertex_buffer_object/mixed-immediate-and-vbo.c b/tests/spec/arb_vertex_buffer_object/mixed-immediate-and-vbo.c
index 67a8d8aa..72d7ea75 100644
--- a/tests/spec/arb_vertex_buffer_object/mixed-immediate-and-vbo.c
+++ b/tests/spec/arb_vertex_buffer_object/mixed-immediate-and-vbo.c
@@ -83,7 +83,7 @@ piglit_display(void)
 	 */
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_source);
 	prog = piglit_link_simple_program(vs, 0);
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
 	glGenBuffersARB(1, &vbo);
 	glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
diff --git a/tests/spec/ext_framebuffer_multisample/draw-buffers-common.cpp b/tests/spec/ext_framebuffer_multisample/draw-buffers-common.cpp
index 6f54dfe8..3831720d 100644
--- a/tests/spec/ext_framebuffer_multisample/draw-buffers-common.cpp
+++ b/tests/spec/ext_framebuffer_multisample/draw-buffers-common.cpp
@@ -192,7 +192,7 @@ shader_compile(bool sample_alpha_to_coverage, bool dual_src_blend)
 	glEnableVertexAttribArray(0);
 
 	/* Linking is rquired after glBindFragDataLocation */
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 
 	/* Set up uniforms */
 	glUseProgram(prog);
diff --git a/tests/spec/ext_texture_swizzle/depth_texture_mode_and_swizzle.c b/tests/spec/ext_texture_swizzle/depth_texture_mode_and_swizzle.c
index 1f90cf44..d0d02700 100644
--- a/tests/spec/ext_texture_swizzle/depth_texture_mode_and_swizzle.c
+++ b/tests/spec/ext_texture_swizzle/depth_texture_mode_and_swizzle.c
@@ -183,10 +183,10 @@ setup_shaders()
 	if (!piglit_link_check_status(prog))
 		piglit_report_result(PIGLIT_FAIL);
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
-	tex_location = piglit_GetUniformLocation(prog, "tex");
-	piglit_Uniform1i(tex_location, 0);
+	tex_location = glGetUniformLocation(prog, "tex");
+	glUniform1i(tex_location, 0);
 }
 
 void
diff --git a/tests/spec/ext_transform_feedback/alignment.c b/tests/spec/ext_transform_feedback/alignment.c
index 3d52e123..ac05bc18 100644
--- a/tests/spec/ext_transform_feedback/alignment.c
+++ b/tests/spec/ext_transform_feedback/alignment.c
@@ -133,11 +133,11 @@ void piglit_init(int argc, char **argv)
 	piglit_require_transform_feedback();
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fstext);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
-	piglit_AttachShader(prog, fs);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
+	glAttachShader(prog, fs);
 	glTransformFeedbackVaryings(prog, 5, varyings, GL_INTERLEAVED_ATTRIBS);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog))
 		piglit_report_result(PIGLIT_FAIL);
 	glGenBuffers(1, &xfb_buf);
@@ -154,7 +154,7 @@ enum piglit_result piglit_display(void)
 	int i;
 	GLboolean pass = GL_TRUE;
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
 	glBindBuffer(GL_ARRAY_BUFFER, 0);
 	glVertexAttribIPointer(input_index, 1, GL_UNSIGNED_INT,
diff --git a/tests/spec/ext_transform_feedback/api-errors.c b/tests/spec/ext_transform_feedback/api-errors.c
index 3e464a70..04470b20 100644
--- a/tests/spec/ext_transform_feedback/api-errors.c
+++ b/tests/spec/ext_transform_feedback/api-errors.c
@@ -202,11 +202,11 @@ do_test(const struct test_desc *test)
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
 	if (test->mode == NOT_A_PROGRAM) {
 		printf("Create a program and then delete it\n");
-		progs[0] = piglit_CreateProgram();
-		piglit_DeleteProgram(progs[0]);
+		progs[0] = glCreateProgram();
+		glDeleteProgram(progs[0]);
 	} else {
-		progs[0] = piglit_CreateProgram();
-		piglit_AttachShader(progs[0], vs);
+		progs[0] = glCreateProgram();
+		glAttachShader(progs[0], vs);
 	}
 
 	pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
@@ -224,17 +224,17 @@ do_test(const struct test_desc *test)
 	}
 
 	printf("Link program\n");
-	piglit_LinkProgram(progs[0]);
+	glLinkProgram(progs[0]);
 	pass = piglit_link_check_status(progs[0]) && pass;
 
 	if (test->mode == USEPROG_ACTIVE || test->mode == LINK_OTHER_ACTIVE) {
 		printf("Prepare 2nd program\n");
-		progs[1] = piglit_CreateProgram();
-		piglit_AttachShader(progs[1], vs);
+		progs[1] = glCreateProgram();
+		glAttachShader(progs[1], vs);
 	}
 	if (test->mode == USEPROG_ACTIVE) {
 		printf("Link 2nd program\n");
-		piglit_LinkProgram(progs[1]);
+		glLinkProgram(progs[1]);
 		pass = piglit_link_check_status(progs[1]) && pass;
 	}
 
@@ -242,7 +242,7 @@ do_test(const struct test_desc *test)
 		printf("Don't use program\n");
 	} else {
 		printf("Use program\n");
-		piglit_UseProgram(progs[0]);
+		glUseProgram(progs[0]);
 	}
 
 	printf("Prepare %i buffers\n", test->num_buffers);
@@ -308,17 +308,17 @@ do_test(const struct test_desc *test)
 		break;
 	case USEPROG_ACTIVE:
 		printf("Use new program\n");
-		piglit_UseProgram(progs[1]);
+		glUseProgram(progs[1]);
 		pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
 		break;
 	case LINK_CURRENT_ACTIVE:
 		printf("Link current program\n");
-		piglit_LinkProgram(progs[0]);
+		glLinkProgram(progs[0]);
 		pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
 		break;
 	case LINK_OTHER_ACTIVE:
 		printf("Link 2nd program\n");
-		piglit_LinkProgram(progs[1]);
+		glLinkProgram(progs[1]);
 		pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
 		break;
 	case BIND_ACTIVE:
diff --git a/tests/spec/ext_transform_feedback/buffer-usage.c b/tests/spec/ext_transform_feedback/buffer-usage.c
index c9d6eda6..8fbae70f 100644
--- a/tests/spec/ext_transform_feedback/buffer-usage.c
+++ b/tests/spec/ext_transform_feedback/buffer-usage.c
@@ -63,15 +63,15 @@ initialize_shader_and_xfb()
 	piglit_require_GLSL_version(130);
 	piglit_require_transform_feedback();
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
 	glTransformFeedbackVaryings(prog, 1, &varying, GL_INTERLEAVED_ATTRIBS);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog)) {
-		piglit_DeleteProgram(prog);
+		glDeleteProgram(prog);
 		piglit_report_result(PIGLIT_FAIL);
 	}
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 }
 
 static void
diff --git a/tests/spec/ext_transform_feedback/builtin-varyings.c b/tests/spec/ext_transform_feedback/builtin-varyings.c
index b71a78ec..3a98a4c7 100644
--- a/tests/spec/ext_transform_feedback/builtin-varyings.c
+++ b/tests/spec/ext_transform_feedback/builtin-varyings.c
@@ -459,16 +459,16 @@ piglit_init(int argc, char **argv)
 	piglit_require_GLSL_version(test_to_run->version);
 	piglit_require_transform_feedback();
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, test_to_run->vs);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
-	piglit_BindAttribLocation(prog, 0, "vertex_pos");
-	piglit_BindAttribLocation(prog, 1, "vertex_num");
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
+	glBindAttribLocation(prog, 0, "vertex_pos");
+	glBindAttribLocation(prog, 1, "vertex_num");
 	glTransformFeedbackVaryings(prog, test_to_run->num_varyings,
 				    (const char **) test_to_run->varyings,
 				    GL_INTERLEAVED_ATTRIBS_EXT);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog)) {
-		piglit_DeleteProgram(prog);
+		glDeleteProgram(prog);
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
diff --git a/tests/spec/ext_transform_feedback/generatemipmap.c b/tests/spec/ext_transform_feedback/generatemipmap.c
index fc5bec93..a41ed611 100644
--- a/tests/spec/ext_transform_feedback/generatemipmap.c
+++ b/tests/spec/ext_transform_feedback/generatemipmap.c
@@ -125,7 +125,7 @@ create_texture(void)
 		glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, sizeof(buffer),
 			     buffer, GL_STREAM_READ);
 		glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfb_buf);
-		piglit_UseProgram(xfb_prog);
+		glUseProgram(xfb_prog);
 		glBeginTransformFeedback(GL_POINTS);
 	}
 	if (prims_written) {
@@ -152,7 +152,7 @@ create_texture(void)
 	}
 	if (buffer || prims_written) {
 		glEndTransformFeedback();
-		piglit_UseProgram(0);
+		glUseProgram(0);
 	}
 	if (buffer) {
 		ptr = glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER_EXT,
@@ -286,11 +286,11 @@ void piglit_init(int argc, char **argv)
 		GLuint vs;
 		piglit_require_GLSL();
 		vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
-		xfb_prog = piglit_CreateProgram();
-		piglit_AttachShader(xfb_prog, vs);
+		xfb_prog = glCreateProgram();
+		glAttachShader(xfb_prog, vs);
 		glTransformFeedbackVaryings(xfb_prog, 1, xfb_varyings,
 					    GL_INTERLEAVED_ATTRIBS);
-		piglit_LinkProgram(xfb_prog);
+		glLinkProgram(xfb_prog);
 		if (!piglit_link_check_status(xfb_prog)) {
 			piglit_report_result(PIGLIT_FAIL);
 		}
diff --git a/tests/spec/ext_transform_feedback/immediate-reuse.c b/tests/spec/ext_transform_feedback/immediate-reuse.c
index 9743ee8f..96cada62 100644
--- a/tests/spec/ext_transform_feedback/immediate-reuse.c
+++ b/tests/spec/ext_transform_feedback/immediate-reuse.c
@@ -86,15 +86,15 @@ piglit_init(int argc, char **argv)
 
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fstext);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
-	piglit_AttachShader(prog, fs);
-	piglit_BindAttribLocation(prog, 0, "in_position");
-	piglit_BindAttribLocation(prog, 1, "in_color");
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
+	glAttachShader(prog, fs);
+	glBindAttribLocation(prog, 0, "in_position");
+	glBindAttribLocation(prog, 1, "in_color");
 	glTransformFeedbackVaryings(prog, 2, varyings, GL_INTERLEAVED_ATTRIBS);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog)) {
-		piglit_DeleteProgram(prog);
+		glDeleteProgram(prog);
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
@@ -137,7 +137,7 @@ piglit_display(void)
 	glEnableVertexAttribArray(0);
 	glEnableVertexAttribArray(1);
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 	glClear(GL_COLOR_BUFFER_BIT);
 
 	/* Draw 16 times, swapping transform feedback and vertex data
diff --git a/tests/spec/ext_transform_feedback/interleaved.c b/tests/spec/ext_transform_feedback/interleaved.c
index ab383061..d23644fc 100644
--- a/tests/spec/ext_transform_feedback/interleaved.c
+++ b/tests/spec/ext_transform_feedback/interleaved.c
@@ -79,13 +79,13 @@ void piglit_init(int argc, char **argv)
 
 	/* Create shaders. */
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
 	glTransformFeedbackVaryings(prog, sizeof(varyings)/sizeof(varyings[0]),
 				    varyings, GL_INTERLEAVED_ATTRIBS_EXT);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog)) {
-		piglit_DeleteProgram(prog);
+		glDeleteProgram(prog);
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
@@ -163,7 +163,7 @@ enum piglit_result piglit_display(void)
 
 	/* Render into TFBO. */
 	glLoadIdentity();
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 	glEnable(GL_RASTERIZER_DISCARD);
 	glBeginTransformFeedback(GL_TRIANGLES);
 	glVertexPointer(2, GL_FLOAT, 0, verts);
diff --git a/tests/spec/ext_transform_feedback/intervening-read.c b/tests/spec/ext_transform_feedback/intervening-read.c
index e30810b0..ac74aa33 100644
--- a/tests/spec/ext_transform_feedback/intervening-read.c
+++ b/tests/spec/ext_transform_feedback/intervening-read.c
@@ -124,15 +124,15 @@ piglit_init(int argc, char **argv)
 
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fstext);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
-	piglit_AttachShader(prog, fs);
-	piglit_BindAttribLocation(prog, 0, "in_position");
-	piglit_BindAttribLocation(prog, 1, "in_color");
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
+	glAttachShader(prog, fs);
+	glBindAttribLocation(prog, 0, "in_position");
+	glBindAttribLocation(prog, 1, "in_color");
 	glTransformFeedbackVaryings(prog, 2, varyings, GL_INTERLEAVED_ATTRIBS);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog)) {
-		piglit_DeleteProgram(prog);
+		glDeleteProgram(prog);
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
diff --git a/tests/spec/ext_transform_feedback/negative-prims.c b/tests/spec/ext_transform_feedback/negative-prims.c
index b6a61b96..f8e51b6e 100644
--- a/tests/spec/ext_transform_feedback/negative-prims.c
+++ b/tests/spec/ext_transform_feedback/negative-prims.c
@@ -169,11 +169,11 @@ piglit_init(int argc, char **argv)
 
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_source);
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fs_source);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
-	piglit_AttachShader(prog, fs);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
+	glAttachShader(prog, fs);
 	glTransformFeedbackVaryings(prog, 1, &varying, GL_INTERLEAVED_ATTRIBS);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!fs || !vs || !prog)
 		piglit_report_result(PIGLIT_FAIL);
 	if (!piglit_link_check_status(prog))
diff --git a/tests/spec/ext_transform_feedback/order.c b/tests/spec/ext_transform_feedback/order.c
index 1021d87a..7b94c3b4 100644
--- a/tests/spec/ext_transform_feedback/order.c
+++ b/tests/spec/ext_transform_feedback/order.c
@@ -144,12 +144,12 @@ initialize_shader_and_xfb()
 	piglit_require_GLSL_version(130);
 	piglit_require_transform_feedback();
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
 	glTransformFeedbackVaryings(prog, 3, varyings, GL_INTERLEAVED_ATTRIBS);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog)) {
-		piglit_DeleteProgram(prog);
+		glDeleteProgram(prog);
 		piglit_report_result(PIGLIT_FAIL);
 	}
 	glGenBuffers(1, &xfb_buf);
@@ -157,7 +157,7 @@ initialize_shader_and_xfb()
 	glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER,
 		     3*NUM_POINTS*sizeof(unsigned), NULL, GL_STREAM_READ);
 	glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, xfb_buf);
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 	if (!piglit_check_gl_error(0))
 		piglit_report_result(PIGLIT_FAIL);
 }
@@ -178,7 +178,7 @@ initialize_vertex_shader_inputs()
 		indices[i + NUM_POINTS/2] = 2*i+1;
 	}
 
-	piglit_Uniform1ui(piglit_GetUniformLocation(prog, "shift_count"),
+	glUniform1ui(glGetUniformLocation(prog, "shift_count"),
 			  SHIFT_COUNT);
 	glVertexAttribIPointer(starting_x_index, 1, GL_UNSIGNED_INT, sizeof(unsigned),
 			       verts);
diff --git a/tests/spec/ext_transform_feedback/output-type.c b/tests/spec/ext_transform_feedback/output-type.c
index 5a37c5fa..d39e9845 100644
--- a/tests/spec/ext_transform_feedback/output-type.c
+++ b/tests/spec/ext_transform_feedback/output-type.c
@@ -1492,14 +1492,14 @@ test_ready:
 
 	/* Create shaders. */
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, test->vs);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
 	glTransformFeedbackVaryings(prog, test->num_varyings,
 				    test->varyings,
 				    GL_INTERLEAVED_ATTRIBS_EXT);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog)) {
-		piglit_DeleteProgram(prog);
+		glDeleteProgram(prog);
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
@@ -1558,7 +1558,7 @@ enum piglit_result piglit_display(void)
 
 	/* Render into TFBO. */
 	glLoadIdentity();
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 	glBeginTransformFeedback(GL_TRIANGLES);
 	glBindBuffer(GL_ARRAY_BUFFER, 0);
 	glVertexPointer(2, GL_FLOAT, 0, verts);
diff --git a/tests/spec/ext_transform_feedback/overflow-edge-cases.c b/tests/spec/ext_transform_feedback/overflow-edge-cases.c
index dc6a3399..87cc5a36 100644
--- a/tests/spec/ext_transform_feedback/overflow-edge-cases.c
+++ b/tests/spec/ext_transform_feedback/overflow-edge-cases.c
@@ -86,14 +86,14 @@ piglit_init(int argc, char **argv)
 
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
 	for (num_varyings = 1; num_varyings <= 2; ++num_varyings) {
-		GLuint prog = piglit_CreateProgram();
-		piglit_AttachShader(prog, vs);
-		piglit_BindAttribLocation(prog, 0, "vertex_num");
+		GLuint prog = glCreateProgram();
+		glAttachShader(prog, vs);
+		glBindAttribLocation(prog, 0, "vertex_num");
 		glTransformFeedbackVaryings(prog, num_varyings, varyings,
 					    GL_INTERLEAVED_ATTRIBS);
-		piglit_LinkProgram(prog);
+		glLinkProgram(prog);
 		if (!piglit_link_check_status(prog)) {
-			piglit_DeleteProgram(prog);
+			glDeleteProgram(prog);
 			piglit_report_result(PIGLIT_FAIL);
 		}
 		progs[num_varyings - 1] = prog;
@@ -132,7 +132,7 @@ test(int bind_size, int num_varyings, int num_primitives, int mode_index)
 	       mode_names[mode_index]);
 
 	/* Setup program and initial buffer contents */
-	piglit_UseProgram(progs[num_varyings - 1]);
+	glUseProgram(progs[num_varyings - 1]);
 	for (i = 0; i < MAX_VERTICES; ++i)
 		vertex_data[i] = i;
 	glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, sizeof(float),
diff --git a/tests/spec/ext_transform_feedback/position.c b/tests/spec/ext_transform_feedback/position.c
index 7e62b749..2baa3cbd 100644
--- a/tests/spec/ext_transform_feedback/position.c
+++ b/tests/spec/ext_transform_feedback/position.c
@@ -111,22 +111,22 @@ void piglit_init(int argc, char **argv)
 
 	/* Create shaders. */
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
 	glTransformFeedbackVaryings(prog, 1, varyings, GL_INTERLEAVED_ATTRIBS_EXT);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog)) {
-		piglit_DeleteProgram(prog);
+		glDeleteProgram(prog);
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vspassthrough);
-	prog_passthrough = piglit_CreateProgram();
-	piglit_AttachShader(prog_passthrough, vs);
+	prog_passthrough = glCreateProgram();
+	glAttachShader(prog_passthrough, vs);
 	glTransformFeedbackVaryings(prog_passthrough, 1, varyings, GL_INTERLEAVED_ATTRIBS_EXT);
-	piglit_LinkProgram(prog_passthrough);
+	glLinkProgram(prog_passthrough);
 	if (!piglit_link_check_status(prog_passthrough)) {
-		piglit_DeleteProgram(prog_passthrough);
+		glDeleteProgram(prog_passthrough);
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
@@ -206,7 +206,7 @@ enum piglit_result piglit_display(void)
 
 	/* Render into TFBO. */
 	glLoadIdentity();
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 	if (discard)
 		glEnable(GL_RASTERIZER_DISCARD_EXT);
 	glBeginTransformFeedback(GL_TRIANGLES);
@@ -237,7 +237,7 @@ enum piglit_result piglit_display(void)
 
 	case RENDER:
 		puts("Testing rendering.");
-		piglit_UseProgram(prog_passthrough);
+		glUseProgram(prog_passthrough);
 		glBindBuffer(GL_ARRAY_BUFFER, buf);
 		glVertexPointer(4, GL_FLOAT, 0, (void*)(intptr_t)(offset * sizeof(float)));
 		glDrawArrays(GL_TRIANGLES, 0, range == MAX_RANGE ? 6 : 3);
diff --git a/tests/spec/ext_transform_feedback/separate.c b/tests/spec/ext_transform_feedback/separate.c
index 50c16143..ee67e2fa 100644
--- a/tests/spec/ext_transform_feedback/separate.c
+++ b/tests/spec/ext_transform_feedback/separate.c
@@ -84,13 +84,13 @@ void piglit_init(int argc, char **argv)
 
 	/* Create shaders. */
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
 	glTransformFeedbackVaryings(prog, sizeof(varyings)/sizeof(varyings[0]),
 				    varyings, GL_SEPARATE_ATTRIBS_EXT);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog)) {
-		piglit_DeleteProgram(prog);
+		glDeleteProgram(prog);
 		piglit_report_result(PIGLIT_FAIL);
 	}
 
@@ -155,7 +155,7 @@ enum piglit_result piglit_display(void)
 
 	/* Render into TFBO. */
 	glLoadIdentity();
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 	glEnable(GL_RASTERIZER_DISCARD);
 	glBeginTransformFeedback(GL_TRIANGLES);
 	glVertexPointer(2, GL_FLOAT, 0, verts);
diff --git a/tests/spec/ext_transform_feedback/tessellation.c b/tests/spec/ext_transform_feedback/tessellation.c
index 96c61c9e..e25409e3 100644
--- a/tests/spec/ext_transform_feedback/tessellation.c
+++ b/tests/spec/ext_transform_feedback/tessellation.c
@@ -305,19 +305,19 @@ initialize_shader_and_xfb()
 	piglit_require_transform_feedback();
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fstext);
-	normal_prog = piglit_CreateProgram();
-	piglit_AttachShader(normal_prog, vs);
-	piglit_AttachShader(normal_prog, fs);
-	piglit_LinkProgram(normal_prog);
+	normal_prog = glCreateProgram();
+	glAttachShader(normal_prog, vs);
+	glAttachShader(normal_prog, fs);
+	glLinkProgram(normal_prog);
 	if (!piglit_link_check_status(normal_prog)) {
 		piglit_report_result(PIGLIT_FAIL);
 	}
-	xfb_prog = piglit_CreateProgram();
-	piglit_AttachShader(xfb_prog, vs);
-	piglit_AttachShader(xfb_prog, fs);
+	xfb_prog = glCreateProgram();
+	glAttachShader(xfb_prog, vs);
+	glAttachShader(xfb_prog, fs);
 	glTransformFeedbackVaryings(xfb_prog, 3, varyings,
 				    GL_INTERLEAVED_ATTRIBS);
-	piglit_LinkProgram(xfb_prog);
+	glLinkProgram(xfb_prog);
 	if (!piglit_link_check_status(xfb_prog)) {
 		piglit_report_result(PIGLIT_FAIL);
 	}
@@ -421,11 +421,11 @@ draw(GLuint prog, bool use_xfb, float y_offset, GLenum mode,
 	float vertex_offset[2] = { -82.0, y_offset };
 	struct vertex_data buffer[BUFFER_SIZE];
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 	setup_vertex_shader_inputs(prog);
-	piglit_Uniform2fv(piglit_GetUniformLocation(prog, "vertex_offset"),
+	glUniform2fv(glGetUniformLocation(prog, "vertex_offset"),
 			  1, vertex_offset);
-	piglit_Uniform1i(piglit_GetUniformLocation(prog, "use_flat_color"),
+	glUniform1i(glGetUniformLocation(prog, "use_flat_color"),
 			 use_flat_color);
 	glBindBuffer(GL_ARRAY_BUFFER, 0);
 	if (use_xfb) {
diff --git a/tests/spec/gl-2.0/api/getattriblocation-conventional.c b/tests/spec/gl-2.0/api/getattriblocation-conventional.c
index 1053f943..d54011f8 100644
--- a/tests/spec/gl-2.0/api/getattriblocation-conventional.c
+++ b/tests/spec/gl-2.0/api/getattriblocation-conventional.c
@@ -61,7 +61,7 @@ void piglit_init(int argc, char **argv)
 	vert = piglit_compile_shader_text(GL_VERTEX_SHADER, vs_code);
 	prog = piglit_link_simple_program(vert, 0);
 
-	loc = piglit_GetAttribLocation(prog, "gl_Vertex");
+	loc = glGetAttribLocation(prog, "gl_Vertex");
 	printf("Attribute location reported for gl_Vertex is %d.\n", loc);
 
 	piglit_report_result(loc == -1 ? PIGLIT_PASS : PIGLIT_FAIL);
diff --git a/tests/spec/glsl-1.10/execution/clipping/clip-plane-transformation.c b/tests/spec/glsl-1.10/execution/clipping/clip-plane-transformation.c
index 6c422050..62c4d7bf 100644
--- a/tests/spec/glsl-1.10/execution/clipping/clip-plane-transformation.c
+++ b/tests/spec/glsl-1.10/execution/clipping/clip-plane-transformation.c
@@ -238,17 +238,17 @@ setup_glsl_programs()
 
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vert);
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, frag);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
-	piglit_AttachShader(prog, fs);
-	piglit_LinkProgram(prog);
-	piglit_DeleteShader(vs);
-	piglit_DeleteShader(fs);
-	piglit_UseProgram(prog);
-	position_angle_loc = piglit_GetUniformLocation(prog, "position_angle");
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
+	glAttachShader(prog, fs);
+	glLinkProgram(prog);
+	glDeleteShader(vs);
+	glDeleteShader(fs);
+	glUseProgram(prog);
+	position_angle_loc = glGetUniformLocation(prog, "position_angle");
 	if (use_clip_vertex) {
 		clipVertex_angle_loc =
-			piglit_GetUniformLocation(prog, "clipVertex_angle");
+			glGetUniformLocation(prog, "clipVertex_angle");
 	}
 }
 
@@ -396,8 +396,8 @@ piglit_display()
 	bool pass = true;
 
 	if (use_glsl) {
-		piglit_Uniform1f(position_angle_loc, 0.0);
-		piglit_Uniform1f(clipVertex_angle_loc, 0.0);
+		glUniform1f(position_angle_loc, 0.0);
+		glUniform1f(clipVertex_angle_loc, 0.0);
 	}
 
 	/* Base behavior: no rotations, so the clipping planes should
@@ -451,11 +451,11 @@ piglit_display()
 		 * effect, because the shader should behave as though
 		 * it set gl_ClipVertex equal to gl_Position.
 		 */
-		piglit_Uniform1f(position_angle_loc, 20.0);
+		glUniform1f(position_angle_loc, 20.0);
 		pass = measure_effects(
 		    "effect of 20deg rotation on gl_Position",
 		    0, 0, 0, 0, use_clip_vertex ? 20 : 0) && pass;
-		piglit_Uniform1f(position_angle_loc, 0.0);
+		glUniform1f(position_angle_loc, 0.0);
 	}
 
 	if (use_clip_vertex) {
@@ -467,11 +467,11 @@ piglit_display()
 		 * gl_Position to be rotated negative 20 degrees with
 		 * respect to gl_ClipVertex.
 		 */
-		piglit_Uniform1f(clipVertex_angle_loc, 20.0);
+		glUniform1f(clipVertex_angle_loc, 20.0);
 		pass = measure_effects(
 		    "effect of 20deg rotation on gl_ClipVertex",
 		    0, 0, 0, 0, -20) && pass;
-		piglit_Uniform1f(clipVertex_angle_loc, 0.0);
+		glUniform1f(clipVertex_angle_loc, 0.0);
 	}
 
 	piglit_present_results();
diff --git a/tests/spec/glsl-1.20/recursion/recursion.c b/tests/spec/glsl-1.20/recursion/recursion.c
index edcba151..5ccd292b 100644
--- a/tests/spec/glsl-1.20/recursion/recursion.c
+++ b/tests/spec/glsl-1.20/recursion/recursion.c
@@ -226,56 +226,56 @@ do_named_test(const char *name)
 
 		printf("Starting test \"%s\":\n", all_tests[i].name);
 
-		prog = piglit_CreateProgram();
+		prog = glCreateProgram();
 
 		for (j = 0; all_tests[i].shader_source[j] != NULL; j++) {
 			GLuint vs;
 
-			vs = piglit_CreateShader(GL_VERTEX_SHADER);
-			piglit_ShaderSource(vs, 1,
+			vs = glCreateShader(GL_VERTEX_SHADER);
+			glShaderSource(vs, 1,
 					    (const GLchar **)
 					    & all_tests[i].shader_source[j],
 					    NULL);
-			piglit_CompileShader(vs);
+			glCompileShader(vs);
 
 			/* Some drivers return a size of 1 for an empty log.
 			 * This is the size of a log that contains only a
 			 * terminating NUL character.
 			 */
 			printf("Compilation info log for shader %u:\n", j);
-			piglit_GetShaderiv(vs, GL_INFO_LOG_LENGTH, &size);
+			glGetShaderiv(vs, GL_INFO_LOG_LENGTH, &size);
 			if (size > 1) {
 				GLchar *info = malloc(size);
 
-				piglit_GetShaderInfoLog(vs, size, NULL, info);
+				glGetShaderInfoLog(vs, size, NULL, info);
 				printf("%s\n", info);
 				free(info);
 			} else {
 				printf("<empty log>\n\n");
 			}
 
-			piglit_AttachShader(prog, vs);
-			piglit_DeleteShader(vs);
+			glAttachShader(prog, vs);
+			glDeleteShader(vs);
 		}
 
-		piglit_LinkProgram(prog);
+		glLinkProgram(prog);
 
 		/* Some drivers return a size of 1 for an empty log.  This is
 		 * the size of a log that contains only a terminating NUL
 		 * character.
 		 */
 		printf("Link info log:\n");
-		piglit_GetProgramiv(prog, GL_INFO_LOG_LENGTH, &size);
+		glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &size);
 		if (size > 1) {
 			GLchar *info = malloc(size);
-			piglit_GetProgramInfoLog(prog, size, NULL, info);
+			glGetProgramInfoLog(prog, size, NULL, info);
 			printf("%s\n", info);
 			free(info);
 		} else {
 			printf("<empty log>\n\n");
 		}
 
-		piglit_GetProgramiv(prog, GL_LINK_STATUS, &ok);
+		glGetProgramiv(prog, GL_LINK_STATUS, &ok);
 		if (ok) {
 			fprintf(stderr,
 				"Shader with recursion compiled and linked, "
@@ -284,7 +284,7 @@ do_named_test(const char *name)
 		}
 		printf("Done with test \"%s\".\n\n", all_tests[i].name);
 
-		piglit_DeleteProgram(prog);
+		glDeleteProgram(prog);
 
 		if (name != NULL)
 			break;
diff --git a/tests/spec/glsl-1.30/execution/clipping/max-clip-distances.c b/tests/spec/glsl-1.30/execution/clipping/max-clip-distances.c
index 8d2c9168..18614404 100644
--- a/tests/spec/glsl-1.30/execution/clipping/max-clip-distances.c
+++ b/tests/spec/glsl-1.30/execution/clipping/max-clip-distances.c
@@ -129,16 +129,16 @@ piglit_display(void)
 	}
 
 	expected_value = max_clip_distances;
-	loc = piglit_GetUniformLocation(prog, "expected_value");
-	piglit_Uniform1i(loc, expected_value);
+	loc = glGetUniformLocation(prog, "expected_value");
+	glUniform1i(loc, expected_value);
 
 	for (test_distances = 0; test_distances <= 1; ++test_distances) {
-		loc = piglit_GetUniformLocation(prog, "test_distances");
-		piglit_Uniform1i(loc, test_distances);
+		loc = glGetUniformLocation(prog, "test_distances");
+		glUniform1i(loc, test_distances);
 		for (test_in_vs = 0; test_in_vs <= 1; ++test_in_vs) {
 			bool pass;
-			loc = piglit_GetUniformLocation(prog, "test_in_vs");
-			piglit_Uniform1i(loc, test_in_vs);
+			loc = glGetUniformLocation(prog, "test_in_vs");
+			glUniform1i(loc, test_in_vs);
 			piglit_draw_rect(-1, -1, 2, 2);
 			pass = piglit_probe_rect_rgba(0, 0, piglit_width,
 						      piglit_height, green);
@@ -166,11 +166,11 @@ piglit_init(int argc, char **argv)
 	piglit_require_GLSL_version(130);
 	vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vert);
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, frag);
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
-	piglit_AttachShader(prog, fs);
-	piglit_LinkProgram(prog);
-	piglit_DeleteShader(vs);
-	piglit_DeleteShader(fs);
-	piglit_UseProgram(prog);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
+	glAttachShader(prog, fs);
+	glLinkProgram(prog);
+	glDeleteShader(vs);
+	glDeleteShader(fs);
+	glUseProgram(prog);
 }
diff --git a/tests/spec/glsl-1.30/execution/fs-discard-exit-2.c b/tests/spec/glsl-1.30/execution/fs-discard-exit-2.c
index edbe97b2..fe941eac 100644
--- a/tests/spec/glsl-1.30/execution/fs-discard-exit-2.c
+++ b/tests/spec/glsl-1.30/execution/fs-discard-exit-2.c
@@ -97,8 +97,8 @@ piglit_display(void)
 
 	for (x = 0; x < 8; x++) {
 		for (y = 0; y < 8; y++) {
-			piglit_Uniform2i(coord1_location, x * 9, y * 9);
-			piglit_Uniform2i(coord2_location, x * 9, y * 9);
+			glUniform2i(coord1_location, x * 9, y * 9);
+			glUniform2i(coord2_location, x * 9, y * 9);
 			piglit_draw_rect(-1.0 + 0.25 * x,
 					 -1.0 + 0.25 * y,
 					 0.25,
@@ -155,8 +155,8 @@ piglit_init(int argc, char **argv)
 	if (!vs || !fs || !prog)
 		piglit_report_result(PIGLIT_FAIL);
 
-	coord1_location = piglit_GetUniformLocation(prog, "coord1");
-	coord2_location = piglit_GetUniformLocation(prog, "coord2");
+	coord1_location = glGetUniformLocation(prog, "coord1");
+	coord2_location = glGetUniformLocation(prog, "coord2");
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 }
diff --git a/tests/spec/glsl-1.30/execution/fs-texelFetch-2D.c b/tests/spec/glsl-1.30/execution/fs-texelFetch-2D.c
index 141c238c..53eae1c4 100644
--- a/tests/spec/glsl-1.30/execution/fs-texelFetch-2D.c
+++ b/tests/spec/glsl-1.30/execution/fs-texelFetch-2D.c
@@ -86,7 +86,7 @@ piglit_display(void)
 		const int height = max(width / 2, 1);
 		const int y = 10 + 20 * l;
 
-		piglit_Uniform1i(lod_location, l);
+		glUniform1i(lod_location, l);
 
 		/* Draw 4 squares with a color sample for each quad */
 		for (q = 0; q < 4; q++) {
@@ -100,7 +100,7 @@ piglit_display(void)
 			else if (q == 2) c = green;
 			else if (q == 3) c = white;
 
-			piglit_Uniform2i(pos_location, tex_x, tex_y);
+			glUniform2i(pos_location, tex_x, tex_y);
 			piglit_draw_rect(x, y, 10, 10);
 
 			if (width > 2) /* below 1 wide no test */
@@ -131,10 +131,10 @@ piglit_init(int argc, char **argv)
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, frag);
 	prog = piglit_link_simple_program(vs, fs);
 
-	tex_location = piglit_GetUniformLocation(prog, "tex");
-	lod_location = piglit_GetUniformLocation(prog, "lod");
-	pos_location = piglit_GetUniformLocation(prog, "pos");
+	tex_location = glGetUniformLocation(prog, "tex");
+	lod_location = glGetUniformLocation(prog, "lod");
+	pos_location = glGetUniformLocation(prog, "pos");
 
-	piglit_UseProgram(prog);
-	piglit_Uniform1i(tex_location, 0);
+	glUseProgram(prog);
+	glUniform1i(tex_location, 0);
 }
diff --git a/tests/spec/glsl-1.30/execution/fs-texelFetchOffset-2D.c b/tests/spec/glsl-1.30/execution/fs-texelFetchOffset-2D.c
index 8bdca7ac..cdfa495f 100644
--- a/tests/spec/glsl-1.30/execution/fs-texelFetchOffset-2D.c
+++ b/tests/spec/glsl-1.30/execution/fs-texelFetchOffset-2D.c
@@ -86,7 +86,7 @@ piglit_display(void)
 		const int height = max(width / 2, 1);
 		const int y = 10 + 20 * l;
 
-		piglit_Uniform1i(lod_location, l);
+		glUniform1i(lod_location, l);
 
 		/* Draw 4 squares with a color sample for each quad */
 		for (q = 0; q < 4; q++) {
@@ -121,7 +121,7 @@ piglit_display(void)
 			} else if (l == 3)
 				if (q == 2) c = blue;
 
-			piglit_Uniform2i(pos_location, tex_x, tex_y);
+			glUniform2i(pos_location, tex_x, tex_y);
 			piglit_draw_rect(x, y, 10, 10);
 
 			if (width > 2 && c != undefined) /* below 1 wide no test */
@@ -152,10 +152,10 @@ piglit_init(int argc, char **argv)
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, frag);
 	prog = piglit_link_simple_program(vs, fs);
 
-	tex_location = piglit_GetUniformLocation(prog, "tex");
-	lod_location = piglit_GetUniformLocation(prog, "lod");
-	pos_location = piglit_GetUniformLocation(prog, "pos");
+	tex_location = glGetUniformLocation(prog, "tex");
+	lod_location = glGetUniformLocation(prog, "lod");
+	pos_location = glGetUniformLocation(prog, "pos");
 
-	piglit_UseProgram(prog);
-	piglit_Uniform1i(tex_location, 0);
+	glUseProgram(prog);
+	glUniform1i(tex_location, 0);
 }
diff --git a/tests/spec/glsl-1.30/execution/isinf-and-isnan.c b/tests/spec/glsl-1.30/execution/isinf-and-isnan.c
index daa76e4d..36a078bc 100644
--- a/tests/spec/glsl-1.30/execution/isinf-and-isnan.c
+++ b/tests/spec/glsl-1.30/execution/isinf-and-isnan.c
@@ -401,17 +401,17 @@ draw_and_readback(float *readback)
 static void
 set_uniform_float_if_present(GLint program, char *name, float value)
 {
-	GLint loc = piglit_GetUniformLocation(program, name);
+	GLint loc = glGetUniformLocation(program, name);
 	if (loc != -1)
-		piglit_Uniform1f(loc, value);
+		glUniform1f(loc, value);
 }
 
 static void
 set_uniform_int_if_present(GLint program, char *name, int value)
 {
-	GLint loc = piglit_GetUniformLocation(program, name);
+	GLint loc = glGetUniformLocation(program, name);
 	if (loc != -1)
-		piglit_Uniform1i(loc, value);
+		glUniform1i(loc, value);
 }
 
 /**
@@ -435,7 +435,7 @@ test_expr(char *expression, int expected_behavior)
 	char *expected_behavior_string;
 
 	/* Create and link a program specifically to test this expression */
-	prog = piglit_CreateProgram();
+	prog = glCreateProgram();
 	sprintf(compute_value_text,
 		"#version 130\n"
 		"uniform float z = 0.0;\n" /* To defeat constant folding */
@@ -447,19 +447,19 @@ test_expr(char *expression, int expected_behavior)
 		"}\n",
 		expression);
 	if (use_fs) {
-		piglit_AttachShader(prog, stock_vs);
-		piglit_AttachShader(prog, main_fs);
-		piglit_AttachShader(prog, do_test_fs);
+		glAttachShader(prog, stock_vs);
+		glAttachShader(prog, main_fs);
+		glAttachShader(prog, do_test_fs);
 		shader = piglit_compile_shader_text(GL_FRAGMENT_SHADER,
 						    compute_value_text);
-		piglit_AttachShader(prog, shader);
+		glAttachShader(prog, shader);
 	} else {
-		piglit_AttachShader(prog, stock_fs);
-		piglit_AttachShader(prog, main_vs);
-		piglit_AttachShader(prog, do_test_vs);
+		glAttachShader(prog, stock_fs);
+		glAttachShader(prog, main_vs);
+		glAttachShader(prog, do_test_vs);
 		shader = piglit_compile_shader_text(GL_VERTEX_SHADER,
 						    compute_value_text);
-		piglit_AttachShader(prog, shader);
+		glAttachShader(prog, shader);
 	}
 	if (use_xfb) {
 		static const char *var_name = "data";
@@ -467,9 +467,9 @@ test_expr(char *expression, int expected_behavior)
 					    GL_SEPARATE_ATTRIBS);
 		glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, xfb_buffer);
 	}
-	piglit_LinkProgram(prog);
-	piglit_DeleteShader(shader);
-	piglit_UseProgram(prog);
+	glLinkProgram(prog);
+	glDeleteShader(shader);
+	glUseProgram(prog);
 
 	/* Set up uniforms */
 	set_uniform_float_if_present(prog, "u_inf", INFINITY);
@@ -586,8 +586,8 @@ test_expr(char *expression, int expected_behavior)
 	}
 	printf("%s\n", pass ? "OK" : "FAIL");
 
-	piglit_UseProgram(0);
-	piglit_DeleteProgram(prog);
+	glUseProgram(0);
+	glDeleteProgram(prog);
 
 	return pass;
 }
diff --git a/tests/spec/glsl-1.40/tf-no-position.c b/tests/spec/glsl-1.40/tf-no-position.c
index 1623c4d4..5682d339 100644
--- a/tests/spec/glsl-1.40/tf-no-position.c
+++ b/tests/spec/glsl-1.40/tf-no-position.c
@@ -78,10 +78,10 @@ void piglit_init(int argc, char **argv)
 	if (!vs)
 		piglit_report_result(PIGLIT_FAIL);
 
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
 	glTransformFeedbackVaryings(prog, 1, &varying, GL_INTERLEAVED_ATTRIBS);
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog))
 		piglit_report_result(PIGLIT_FAIL);
 	glGenBuffers(1, &xfb_buf);
@@ -90,7 +90,7 @@ void piglit_init(int argc, char **argv)
 
 	input_index = glGetAttribLocation(prog, "i");
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
 	glBindBuffer(GL_ARRAY_BUFFER, 0);
 	glVertexAttribIPointer(input_index, 1, GL_UNSIGNED_INT,
diff --git a/tests/spec/nv_texture_barrier/blending-in-shader.c b/tests/spec/nv_texture_barrier/blending-in-shader.c
index a6fab4d4..951746fa 100644
--- a/tests/spec/nv_texture_barrier/blending-in-shader.c
+++ b/tests/spec/nv_texture_barrier/blending-in-shader.c
@@ -61,7 +61,7 @@ enum piglit_result piglit_display(void)
 	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
 	glViewport(0, 0, 16, 16);
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 	glUniform1i(texloc, 0);
 
 	for (i = 0; i < PASSES; i++) {
@@ -72,7 +72,7 @@ enum piglit_result piglit_display(void)
 
 	pass = piglit_probe_image_rgba(0, 0, 16, 16, res_data);
 
-	piglit_UseProgram(0);
+	glUseProgram(0);
 	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
 	glViewport(0, 0, piglit_width, piglit_height);
 
@@ -118,5 +118,5 @@ void piglit_init(int argc, char **argv)
 	fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fstext);
 	prog = piglit_link_simple_program(0, fs);
 
-	texloc = piglit_GetUniformLocation(prog, "fb");
+	texloc = glGetUniformLocation(prog, "fb");
 }
diff --git a/tests/texturing/incomplete-texture.c b/tests/texturing/incomplete-texture.c
index ce68b735..864aeb25 100644
--- a/tests/texturing/incomplete-texture.c
+++ b/tests/texturing/incomplete-texture.c
@@ -184,8 +184,8 @@ test_glsl(void)
 	draw_rect(2);
 
 	glUseProgram(0);
-	piglit_DeleteShader(frag);
-	piglit_DeleteProgram(prog);
+	glDeleteShader(frag);
+	glDeleteProgram(prog);
 
 	p = probe_pos(pos, expected);
 	if (!p)
diff --git a/tests/texturing/shaders/texelFetch.c b/tests/texturing/shaders/texelFetch.c
index 751863e7..4ee607ef 100644
--- a/tests/texturing/shaders/texelFetch.c
+++ b/tests/texturing/shaders/texelFetch.c
@@ -492,14 +492,14 @@ generate_GLSL(enum shader_target test_stage)
 		printf("FS code:\n%s", fs_code);
 		piglit_report_result(PIGLIT_FAIL);
 	}
-	prog = piglit_CreateProgram();
-	piglit_AttachShader(prog, vs);
-	piglit_AttachShader(prog, fs);
+	prog = glCreateProgram();
+	glAttachShader(prog, vs);
+	glAttachShader(prog, fs);
 
 	glBindAttribLocation(prog, pos_loc, "pos");
 	glBindAttribLocation(prog, texcoord_loc, "texcoord");
 
-	piglit_LinkProgram(prog);
+	glLinkProgram(prog);
 	if (!piglit_link_check_status(prog))
 		piglit_report_result(PIGLIT_FAIL);
 
@@ -596,12 +596,12 @@ piglit_init(int argc, char **argv)
 
 	prog = generate_GLSL(test_stage);
 
-	tex_location = piglit_GetUniformLocation(prog, "tex");
-	divisor_loc = piglit_GetUniformLocation(prog, "divisor");
+	tex_location = glGetUniformLocation(prog, "tex");
+	divisor_loc = glGetUniformLocation(prog, "divisor");
 
-	piglit_UseProgram(prog);
+	glUseProgram(prog);
 
-	piglit_Uniform1i(tex_location, 0);
+	glUniform1i(tex_location, 0);
 
 	/* Create textures and set miplevel info */
 	set_base_size();
diff --git a/tests/texturing/shaders/textureSize.c b/tests/texturing/shaders/textureSize.c
index 91684584..6adca7fe 100644
--- a/tests/texturing/shaders/textureSize.c
+++ b/tests/texturing/shaders/textureSize.c
@@ -137,7 +137,7 @@ piglit_display()
 		}
 		expected_color[3] = 1.0;
 
-		piglit_Uniform1i(lod_location, l);
+		glUniform1i(lod_location, l);
 		glViewport(x, 10, 10, 10);
 		glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
@@ -348,11 +348,11 @@ piglit_init(int argc, char **argv)
 	if (!prog)
 		piglit_report_result(PIGLIT_FAIL);
 
-	tex_location = piglit_GetUniformLocation(prog, "tex");
-	lod_location = piglit_GetUniformLocation(prog, "lod");
-	vertex_location = piglit_GetAttribLocation(prog, "vertex");
-	piglit_UseProgram(prog);
-	piglit_Uniform1i(tex_location, 0);
+	tex_location = glGetUniformLocation(prog, "tex");
+	lod_location = glGetUniformLocation(prog, "lod");
+	vertex_location = glGetAttribLocation(prog, "vertex");
+	glUseProgram(prog);
+	glUniform1i(tex_location, 0);
 
 	/* Create textures and set miplevel info */
 	set_base_size();
diff --git a/tests/texturing/tex-miplevel-selection.c b/tests/texturing/tex-miplevel-selection.c
index 834c1381..f3b7f5bd 100644
--- a/tests/texturing/tex-miplevel-selection.c
+++ b/tests/texturing/tex-miplevel-selection.c
@@ -94,10 +94,10 @@ piglit_init(int argc, char **argv)
 
 		fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fscode);
 		prog = piglit_link_simple_program(0, fs);
-		piglit_UseProgram(prog);
-		loc_tex = piglit_GetUniformLocation(prog, "tex");
-		loc_lod = piglit_GetUniformLocation(prog, "lod");
-		piglit_Uniform1i(loc_tex, 0);
+		glUseProgram(prog);
+		loc_tex = glGetUniformLocation(prog, "tex");
+		loc_lod = glGetUniformLocation(prog, "lod");
+		glUniform1i(loc_tex, 0);
 
 		puts("Testing GL_ARB_shader_texture_lod.");
 	}
@@ -164,7 +164,7 @@ draw_quad(int x, int y, int w, int h, int level)
 
 	if (ARB_shader_texture_lod) {
 		float lod = level;
-		piglit_Uniform1fv(loc_lod, 1, &lod);
+		glUniform1fv(loc_lod, 1, &lod);
 
 		s = w/(float)TEX_WIDTH;
 		t = h/(float)TEX_HEIGHT;
diff --git a/tests/texturing/texwrap.c b/tests/texturing/texwrap.c
index ce0f7a2e..6d7dbb61 100644
--- a/tests/texturing/texwrap.c
+++ b/tests/texturing/texwrap.c
@@ -826,16 +826,16 @@ static void draw(const struct format_desc *format,
 	switch (format->type) {
 	case INT_TYPE:
 		scale[0] = scale[1] = scale[2] = scale[3] = 1.0/((1ull << (bits-1))-1);
-		piglit_UseProgram(prog_int);
-		piglit_Uniform4fv(int_scale_loc, 1, scale);
+		glUseProgram(prog_int);
+		glUniform4fv(int_scale_loc, 1, scale);
 		break;
 	case UINT_TYPE:
 		scale[0] = scale[1] = scale[2] = scale[3] = 1.0/((1ull << bits)-1);
 		if (bits == 10) {
 			scale[3] = 1.0/3;
 		}
-		piglit_UseProgram(prog_uint);
-		piglit_Uniform4fv(uint_scale_loc, 1, scale);
+		glUseProgram(prog_uint);
+		glUniform4fv(uint_scale_loc, 1, scale);
 		break;
 	default:;
 	}
@@ -936,7 +936,7 @@ static void draw(const struct format_desc *format,
 	switch (format->type) {
 	case INT_TYPE:
 	case UINT_TYPE:
-		piglit_UseProgram(0);
+		glUseProgram(0);
 		break;
 	default:;
 	}
@@ -1766,14 +1766,14 @@ outer_continue:;
 		assert(fp);
 		prog_int = piglit_link_simple_program(0, fp);
 		assert(prog_int);
-		int_scale_loc = piglit_GetUniformLocation(prog_int, "scale");
+		int_scale_loc = glGetUniformLocation(prog_int, "scale");
 		assert(int_scale_loc != -1);
 
 		fp = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fp_uint);
 		assert(fp);
 		prog_uint = piglit_link_simple_program(0, fp);
 		assert(prog_uint);
-		uint_scale_loc = piglit_GetUniformLocation(prog_uint, "scale");
+		uint_scale_loc = glGetUniformLocation(prog_uint, "scale");
 		assert(uint_scale_loc != -1);
 		break;
 	default:;
diff --git a/tests/util/piglit-shader-gl.c b/tests/util/piglit-shader-gl.c
index 1ca443e9..33735cc7 100644
--- a/tests/util/piglit-shader-gl.c
+++ b/tests/util/piglit-shader-gl.c
@@ -31,173 +31,12 @@
 
 #include "piglit-util-gl-common.h"
 
-PFNGLATTACHSHADERPROC piglit_AttachShader = NULL;
-PFNGLBINDATTRIBLOCATIONPROC piglit_BindAttribLocation = NULL;
-PFNGLCOMPILESHADERPROC piglit_CompileShader = NULL;
-PFNGLCREATEPROGRAMPROC piglit_CreateProgram = NULL;
-PFNGLCREATESHADERPROC piglit_CreateShader = NULL;
-PFNGLDELETEPROGRAMPROC piglit_DeleteProgram = NULL;
-PFNGLDELETESHADERPROC piglit_DeleteShader = NULL;
-PFNGLGETACTIVEUNIFORMPROC piglit_GetActiveUniform = NULL;
-PFNGLGETATTRIBLOCATIONPROC piglit_GetAttribLocation = NULL;
-PFNGLGETPROGRAMINFOLOGPROC piglit_GetProgramInfoLog = NULL;
-PFNGLGETPROGRAMIVPROC piglit_GetProgramiv = NULL;
-PFNGLGETSHADERINFOLOGPROC piglit_GetShaderInfoLog = NULL;
-PFNGLGETSHADERIVPROC piglit_GetShaderiv = NULL;
-PFNGLGETUNIFORMLOCATIONPROC piglit_GetUniformLocation = NULL;
-PFNGLLINKPROGRAMPROC piglit_LinkProgram = NULL;
-PFNGLSHADERSOURCEPROC piglit_ShaderSource = NULL;
-PFNGLUSEPROGRAMPROC piglit_UseProgram = NULL;
-PFNGLUNIFORM1FPROC piglit_Uniform1f = NULL;
-PFNGLUNIFORM2FPROC piglit_Uniform2f = NULL;
-PFNGLUNIFORM3FPROC piglit_Uniform3f = NULL;
-PFNGLUNIFORM4FPROC piglit_Uniform4f = NULL;
-PFNGLUNIFORM1FVPROC piglit_Uniform1fv = NULL;
-PFNGLUNIFORM2FVPROC piglit_Uniform2fv = NULL;
-PFNGLUNIFORM3FVPROC piglit_Uniform3fv = NULL;
-PFNGLUNIFORM4FVPROC piglit_Uniform4fv = NULL;
-PFNGLUNIFORM1IPROC piglit_Uniform1i = NULL;
-PFNGLUNIFORM2IPROC piglit_Uniform2i = NULL;
-PFNGLUNIFORM3IPROC piglit_Uniform3i = NULL;
-PFNGLUNIFORM4IPROC piglit_Uniform4i = NULL;
-PFNGLUNIFORM1IVPROC piglit_Uniform1iv = NULL;
-PFNGLUNIFORM2IVPROC piglit_Uniform2iv = NULL;
-PFNGLUNIFORM3IVPROC piglit_Uniform3iv = NULL;
-PFNGLUNIFORM4IVPROC piglit_Uniform4iv = NULL;
-PFNGLUNIFORM1UIPROC piglit_Uniform1ui = NULL;
-PFNGLUNIFORM2UIPROC piglit_Uniform2ui = NULL;
-PFNGLUNIFORM3UIPROC piglit_Uniform3ui = NULL;
-PFNGLUNIFORM4UIPROC piglit_Uniform4ui = NULL;
-PFNGLUNIFORM1UIVPROC piglit_Uniform1uiv = NULL;
-PFNGLUNIFORM2UIVPROC piglit_Uniform2uiv = NULL;
-PFNGLUNIFORM3UIVPROC piglit_Uniform3uiv = NULL;
-PFNGLUNIFORM4UIVPROC piglit_Uniform4uiv = NULL;
-PFNGLUNIFORMMATRIX2FVPROC piglit_UniformMatrix2fv = NULL;
-PFNGLUNIFORMMATRIX3FVPROC piglit_UniformMatrix3fv = NULL;
-PFNGLUNIFORMMATRIX4FVPROC piglit_UniformMatrix4fv = NULL;
-PFNGLGETUNIFORMFVPROC piglit_GetUniformfv = NULL;
-PFNGLVERTEXATTRIBPOINTERPROC piglit_VertexAttribPointer = NULL;
-PFNGLENABLEVERTEXATTRIBARRAYPROC piglit_EnableVertexAttribArray = NULL;
-PFNGLDISABLEVERTEXATTRIBARRAYPROC piglit_DisableVertexAttribArray = NULL;
-
-PFNGLUNIFORMMATRIX2X3FVPROC piglit_UniformMatrix2x3fv = NULL;
-PFNGLUNIFORMMATRIX2X4FVPROC piglit_UniformMatrix2x4fv = NULL;
-PFNGLUNIFORMMATRIX3X2FVPROC piglit_UniformMatrix3x2fv = NULL;
-PFNGLUNIFORMMATRIX3X4FVPROC piglit_UniformMatrix3x4fv = NULL;
-PFNGLUNIFORMMATRIX4X2FVPROC piglit_UniformMatrix4x2fv = NULL;
-PFNGLUNIFORMMATRIX4X3FVPROC piglit_UniformMatrix4x3fv = NULL;
-
-static void
-init_functions_from_core(void)
-{
-	piglit_AttachShader = glAttachShader;
-	piglit_BindAttribLocation = glBindAttribLocation;
-	piglit_CompileShader = glCompileShader;
-	piglit_CreateProgram = glCreateProgram;
-	piglit_CreateShader = glCreateShader;
-	piglit_DeleteProgram = glDeleteProgram;
-	piglit_DeleteShader = glDeleteShader;
-	piglit_GetActiveUniform = glGetActiveUniform;
-	piglit_GetAttribLocation = glGetAttribLocation;
-	piglit_GetProgramInfoLog = glGetProgramInfoLog;
-	piglit_GetProgramiv = glGetProgramiv;
-	piglit_GetShaderInfoLog = glGetShaderInfoLog;
-	piglit_GetShaderiv = glGetShaderiv;
-	piglit_GetUniformLocation = glGetUniformLocation;
-	piglit_LinkProgram = glLinkProgram;
-	piglit_ShaderSource = glShaderSource;
-	piglit_UseProgram = glUseProgram;
-	piglit_Uniform1f = glUniform1f;
-	piglit_Uniform2f = glUniform2f;
-	piglit_Uniform3f = glUniform3f;
-	piglit_Uniform4f = glUniform4f;
-	piglit_Uniform1fv = glUniform1fv;
-	piglit_Uniform2fv = glUniform2fv;
-	piglit_Uniform3fv = glUniform3fv;
-	piglit_Uniform4fv = glUniform4fv;
-	piglit_Uniform1i = glUniform1i;
-	piglit_Uniform2i = glUniform2i;
-	piglit_Uniform3i = glUniform3i;
-	piglit_Uniform4i = glUniform4i;
-	piglit_Uniform1iv = glUniform1iv;
-	piglit_Uniform2iv = glUniform2iv;
-	piglit_Uniform3iv = glUniform3iv;
-	piglit_Uniform4iv = glUniform4iv;
-	piglit_Uniform1ui = glUniform1ui;
-	piglit_Uniform2ui = glUniform2ui;
-	piglit_Uniform3ui = glUniform3ui;
-	piglit_Uniform4ui = glUniform4ui;
-	piglit_Uniform1uiv = glUniform1uiv;
-	piglit_Uniform2uiv = glUniform2uiv;
-	piglit_Uniform3uiv = glUniform3uiv;
-	piglit_Uniform4uiv = glUniform4uiv;
-	piglit_UniformMatrix2fv = glUniformMatrix2fv;
-	piglit_UniformMatrix3fv = glUniformMatrix3fv;
-	piglit_UniformMatrix4fv = glUniformMatrix4fv;
-	piglit_GetUniformfv = glGetUniformfv;
-	piglit_VertexAttribPointer = glVertexAttribPointer;
-	piglit_EnableVertexAttribArray = glEnableVertexAttribArray;
-	piglit_DisableVertexAttribArray = glDisableVertexAttribArray;
-
-	/* These are part of OpenGL 2.1.
-	 */
-	piglit_UniformMatrix2x3fv = glUniformMatrix2x3fv;
-	piglit_UniformMatrix2x4fv = glUniformMatrix2x4fv;
-	piglit_UniformMatrix3x2fv = glUniformMatrix3x2fv;
-	piglit_UniformMatrix3x4fv = glUniformMatrix3x4fv;
-	piglit_UniformMatrix4x2fv = glUniformMatrix4x2fv;
-	piglit_UniformMatrix4x3fv = glUniformMatrix4x3fv;
-}
-
-static void
-init_functions_from_extension(void)
-{
-	piglit_AttachShader = glAttachObjectARB;
-	piglit_BindAttribLocation = glBindAttribLocationARB;
-	piglit_CompileShader = glCompileShaderARB;
-	piglit_CreateProgram = glCreateProgramObjectARB;
-	piglit_CreateShader = glCreateShaderObjectARB;
-	piglit_DeleteProgram = glDeleteObjectARB;
-	piglit_DeleteShader = glDeleteObjectARB;
-	piglit_GetActiveUniform = glGetActiveUniformARB;
-	piglit_GetAttribLocation = glGetAttribLocationARB;
-	piglit_GetProgramInfoLog = glGetInfoLogARB;
-	piglit_GetProgramiv = glGetObjectParameterivARB;
-	piglit_GetShaderInfoLog = glGetInfoLogARB;
-	piglit_GetShaderiv = glGetObjectParameterivARB;
-	piglit_GetUniformLocation = glGetUniformLocationARB;
-	piglit_LinkProgram = glLinkProgramARB;
-	piglit_ShaderSource = glShaderSourceARB;
-	piglit_UseProgram = glUseProgramObjectARB;
-	piglit_Uniform1f = glUniform1fARB;
-	piglit_Uniform2f = glUniform2fARB;
-	piglit_Uniform3f = glUniform3fARB;
-	piglit_Uniform4f = glUniform4fARB;
-	piglit_Uniform1fv = glUniform1fvARB;
-	piglit_Uniform2fv = glUniform2fvARB;
-	piglit_Uniform3fv = glUniform3fvARB;
-	piglit_Uniform4fv = glUniform4fvARB;
-	piglit_Uniform1i = glUniform1iARB;
-	piglit_Uniform2iv = glUniform2ivARB;
-	piglit_Uniform3iv = glUniform3ivARB;
-	piglit_Uniform4iv = glUniform4ivARB;
-	piglit_UniformMatrix2fv = glUniformMatrix2fvARB;
-	piglit_UniformMatrix3fv = glUniformMatrix3fvARB;
-	piglit_UniformMatrix4fv = glUniformMatrix4fvARB;
-	piglit_GetUniformfv = glGetUniformfvARB;
-	piglit_VertexAttribPointer = glVertexAttribPointerARB;
-	piglit_EnableVertexAttribArray = glEnableVertexAttribArrayARB;
-	piglit_DisableVertexAttribArray = glDisableVertexAttribArrayARB;
-}
-
 void
 piglit_require_GLSL(void)
 {
-	if (piglit_get_gl_version() >= 20) {
-		init_functions_from_core();
-	} else if (piglit_is_extension_supported("GL_ARB_shader_objects") && piglit_is_extension_supported("GL_ARB_shading_language_100")) {
-		init_functions_from_extension();
-	} else {
+	if (piglit_get_gl_version() < 20
+	    && !(piglit_is_extension_supported("GL_ARB_shader_objects")
+	         && piglit_is_extension_supported("GL_ARB_shading_language_100"))) {
 		printf("GLSL not supported.\n");
 		piglit_report_result(PIGLIT_SKIP);
 		exit(1);
@@ -225,11 +64,9 @@ piglit_require_GLSL_version(int version)
 void
 piglit_require_vertex_shader(void)
 {
-	if (piglit_get_gl_version() >= 20) {
-		init_functions_from_core();
-	} else if (piglit_is_extension_supported("GL_ARB_shader_objects") && piglit_is_extension_supported("GL_ARB_vertex_shader")) {
-		init_functions_from_extension();
-	} else {
+	if (piglit_get_gl_version() < 20
+	    && !(piglit_is_extension_supported("GL_ARB_shader_objects")
+		 && piglit_is_extension_supported("GL_ARB_vertex_shader"))) {
 		printf("GLSL vertex shaders are not supported.\n");
 		piglit_report_result(PIGLIT_SKIP);
 		exit(1);
@@ -239,12 +76,10 @@ piglit_require_vertex_shader(void)
 void
 piglit_require_fragment_shader(void)
 {
-	if (piglit_get_gl_version() >= 20) {
-		init_functions_from_core();
-	} else if (piglit_is_extension_supported("GL_ARB_shader_objects") && piglit_is_extension_supported("GL_ARB_fragment_shader")) {
-		init_functions_from_extension();
-	} else {
-		printf("GLSL vertex shaders are not supported.\n");
+	if (piglit_get_gl_version() < 20
+	    && !(piglit_is_extension_supported("GL_ARB_shader_objects")
+		 && piglit_is_extension_supported("GL_ARB_fragment_shader"))) {
+		printf("GLSL fragment shaders are not supported.\n");
 		piglit_report_result(PIGLIT_SKIP);
 		exit(1);
 	}
diff --git a/tests/util/piglit-shader.c b/tests/util/piglit-shader.c
index 89021e32..dbe8bc11 100644
--- a/tests/util/piglit-shader.c
+++ b/tests/util/piglit-shader.c
@@ -140,25 +140,25 @@ piglit_compile_shader_text(GLenum target, const char *text)
 
 	piglit_require_GLSL();
 
-	prog = piglit_CreateShader(target);
-	piglit_ShaderSource(prog, 1, (const GLchar **) &text, NULL);
-	piglit_CompileShader(prog);
+	prog = glCreateShader(target);
+	glShaderSource(prog, 1, (const GLchar **) &text, NULL);
+	glCompileShader(prog);
 
-	piglit_GetShaderiv(prog, GL_COMPILE_STATUS, &ok);
+	glGetShaderiv(prog, GL_COMPILE_STATUS, &ok);
 
 	{
 		GLchar *info;
 		GLint size;
 
-		piglit_GetShaderiv(prog, GL_INFO_LOG_LENGTH, &size);
+		glGetShaderiv(prog, GL_INFO_LOG_LENGTH, &size);
 		info = malloc(size);
 
-		piglit_GetShaderInfoLog(prog, size, NULL, info);
+		glGetShaderInfoLog(prog, size, NULL, info);
 		if (!ok) {
 			fprintf(stderr, "Failed to compile %s shader: %s\n",
 				shader_name(target),
 				info);
-			piglit_DeleteShader(prog);
+			glDeleteShader(prog);
 			prog = 0;
 		}
 		else if (0) {
@@ -183,15 +183,15 @@ link_check_status(GLint prog, FILE *output)
 
 	piglit_require_GLSL();
 
-	piglit_GetProgramiv(prog, GL_LINK_STATUS, &ok);
+	glGetProgramiv(prog, GL_LINK_STATUS, &ok);
 
 	/* Some drivers return a size of 1 for an empty log.  This is the size
 	 * of a log that contains only a terminating NUL character.
 	 */
-	piglit_GetProgramiv(prog, GL_INFO_LOG_LENGTH, &size);
+	glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &size);
 	if (size > 1) {
 		info = malloc(size);
-		piglit_GetProgramInfoLog(prog, size, NULL, info);
+		glGetProgramInfoLog(prog, size, NULL, info);
 	}
 
 	if (!ok) {
@@ -239,15 +239,15 @@ GLint piglit_link_simple_program(GLint vs, GLint fs)
 
 	piglit_require_GLSL();
 
-	prog = piglit_CreateProgram();
+	prog = glCreateProgram();
 	if (vs)
-		piglit_AttachShader(prog, vs);
+		glAttachShader(prog, vs);
 	if (fs)
-		piglit_AttachShader(prog, fs);
-	piglit_LinkProgram(prog);
+		glAttachShader(prog, fs);
+	glLinkProgram(prog);
 
 	if (!piglit_link_check_status(prog)) {
-		piglit_DeleteProgram(prog);
+		glDeleteProgram(prog);
 		prog = 0;
 	}
 
diff --git a/tests/util/piglit-shader.h b/tests/util/piglit-shader.h
index 50bd4af6..12cf731b 100644
--- a/tests/util/piglit-shader.h
+++ b/tests/util/piglit-shader.h
@@ -36,158 +36,57 @@ GLboolean piglit_link_check_status(GLint prog);
 GLboolean piglit_link_check_status_quiet(GLint prog);
 GLint piglit_link_simple_program(GLint vs, GLint fs);
 
-/**
- * \name Portable wrappers for GLSL functions\
- *
- * \note
- * One of \c piglit_require_GLSL, \c piglit_require_vertex_shader, or
- * \c piglit_require_fragment_shader must be called before using these
- * wrappers.
- */
-/*@{*/
 #if defined(PIGLIT_USE_OPENGL_ES1)
-#define piglit_AttachShader assert(!"glAttachShader does not exist in ES1")
-#define piglit_BindAttribLocation assert(!"glBindAttribLocation does not exist in ES1")
-#define piglit_CompileShader assert(!"glCompileShader does not exist in ES1")
-#define piglit_CreateProgram assert(!"glCreateProgram does not exist in ES1")
-#define piglit_CreateShader assert(!"glCreateShader does not exist in ES1")
-#define piglit_DeleteProgram assert(!"glDeleteProgram does not exist in ES1")
-#define piglit_DeleteShader assert(!"glDeleteShader does not exist in ES1")
-#define piglit_GetActiveUniform assert(!"glGetActiveUniform does not exist in ES1")
-#define piglit_GetAttribLocation assert(!"glGetAttribLocation does not exist in ES1")
-#define piglit_GetProgramInfoLog assert(!"glGetProgramInfoLog does not exist in ES1")
-#define piglit_GetProgramiv assert(!"glGetProgramiv does not exist in ES1")
-#define piglit_GetShaderInfoLog assert(!"glGetShaderInfoLog does not exist in ES1")
-#define piglit_GetShaderiv assert(!"glGetShaderiv does not exist in ES1")
-#define piglit_GetUniformLocation assert(!"glGetUniformLocation does not exist in ES1")
-#define piglit_LinkProgram assert(!"glLinkProgram does not exist in ES1")
-#define piglit_ShaderSource assert(!"glShaderSource does not exist in ES1")
-#define piglit_UseProgram assert(!"glUseProgram does not exist in ES1")
-#define piglit_Uniform1f assert(!"glUniform1f does not exist in ES1")
-#define piglit_Uniform2f assert(!"glUniform2f does not exist in ES1")
-#define piglit_Uniform3f assert(!"glUniform3f does not exist in ES1")
-#define piglit_Uniform4f assert(!"glUniform4f does not exist in ES1")
-#define piglit_Uniform1fv assert(!"glUniform1fv does not exist in ES1")
-#define piglit_Uniform2fv assert(!"glUniform2fv does not exist in ES1")
-#define piglit_Uniform3fv assert(!"glUniform3fv does not exist in ES1")
-#define piglit_Uniform4fv assert(!"glUniform4fv does not exist in ES1")
-#define piglit_Uniform1i assert(!"glUniform1i does not exist in ES1")
-#define piglit_Uniform2iv assert(!"glUniform2iv does not exist in ES1")
-#define piglit_Uniform3iv assert(!"glUniform3iv does not exist in ES1")
-#define piglit_Uniform4iv assert(!"glUniform4iv does not exist in ES1")
-#define piglit_UniformMatrix2fv assert(!"glUniformMatrix2fv does not exist in ES1")
-#define piglit_UniformMatrix3fv assert(!"glUniformMatrix3fv does not exist in ES1")
-#define piglit_UniformMatrix4fv assert(!"glUniformMatrix4fv does not exist in ES1")
-#define piglit_GetUniformfv assert(!"glGetUniformfv does not exist in ES1")
-#define piglit_VertexAttribPointer assert(!"glVertexAttribPointer does not exist in ES1")
-#define piglit_EnableVertexAttribArray assert(!"glEnableVertexAttribArray does not exist in ES1")
-#define piglit_DisableVertexAttribArray assert(!"glDisableVertexAttribArray does not exist in ES1")
-#define piglit_UniformMatrix2x3fv assert(!"glUniformMatrix2x3fv does not exist in ES1")
-#define piglit_UniformMatrix2x4fv assert(!"glUniformMatrix2x4fv does not exist in ES1")
-#define piglit_UniformMatrix3x2fv assert(!"glUniformMatrix3x2fv does not exist in ES1")
-#define piglit_UniformMatrix3x4fv assert(!"glUniformMatrix3x4fv does not exist in ES1")
-#define piglit_UniformMatrix4x2fv assert(!"glUniformMatrix4x2fv does not exist in ES1")
-#define piglit_UniformMatrix4x3fv assert(!"glUniformMatrix4x3fv does not exist in ES1")
-#elif defined(PIGLIT_USE_OPENGL_ES2)
-#define piglit_AttachShader glAttachShader
-#define piglit_BindAttribLocation glBindAttribLocation
-#define piglit_CompileShader glCompileShader
-#define piglit_CreateProgram glCreateProgram
-#define piglit_CreateShader glCreateShader
-#define piglit_DeleteProgram glDeleteProgram
-#define piglit_DeleteShader glDeleteShader
-#define piglit_GetActiveUniform glGetActiveUniform
-#define piglit_GetAttribLocation glGetAttribLocation
-#define piglit_GetProgramInfoLog glGetProgramInfoLog
-#define piglit_GetProgramiv glGetProgramiv
-#define piglit_GetShaderInfoLog glGetShaderInfoLog
-#define piglit_GetShaderiv glGetShaderiv
-#define piglit_GetUniformLocation glGetUniformLocation
-#define piglit_LinkProgram glLinkProgram
-#define piglit_ShaderSource glShaderSource
-#define piglit_UseProgram glUseProgram
-#define piglit_Uniform1f glUniform1f
-#define piglit_Uniform2f glUniform2f
-#define piglit_Uniform3f glUniform3f
-#define piglit_Uniform4f glUniform4f
-#define piglit_Uniform1fv glUniform1fv
-#define piglit_Uniform2fv glUniform2fv
-#define piglit_Uniform3fv glUniform3fv
-#define piglit_Uniform4fv glUniform4fv
-#define piglit_Uniform1i glUniform1i
-#define piglit_Uniform2iv glUniform2iv
-#define piglit_Uniform3iv glUniform3iv
-#define piglit_Uniform4iv glUniform4iv
-#define piglit_UniformMatrix2fv glUniformMatrix2fv
-#define piglit_UniformMatrix3fv glUniformMatrix3fv
-#define piglit_UniformMatrix4fv glUniformMatrix4fv
-#define piglit_GetUniformfv glGetUniformfv
-#define piglit_VertexAttribPointer glVertexAttribPointer
-#define piglit_EnableVertexAttribArray glEnableVertexAttribArray
-#define piglit_DisableVertexAttribArray glDisableVertexAttribArray
-#define piglit_UniformMatrix2x3fv assert(!"glUniformMatrix2x3fv does not exist in ES")
-#define piglit_UniformMatrix2x4fv assert(!"glUniformMatrix2x4fv does not exist in ES")
-#define piglit_UniformMatrix3x2fv assert(!"glUniformMatrix3x2fv does not exist in ES")
-#define piglit_UniformMatrix3x4fv assert(!"glUniformMatrix3x4fv does not exist in ES")
-#define piglit_UniformMatrix4x2fv assert(!"glUniformMatrix4x2fv does not exist in ES")
-#define piglit_UniformMatrix4x3fv assert(!"glUniformMatrix4x3fv does not exist in ES")
-#elif defined(PIGLIT_USE_OPENGL) || defined(PIGLIT_USE_OPENGL_ES2)
-extern PFNGLATTACHSHADERPROC piglit_AttachShader;
-extern PFNGLBINDATTRIBLOCATIONPROC piglit_BindAttribLocation;
-extern PFNGLCOMPILESHADERPROC piglit_CompileShader;
-extern PFNGLCREATEPROGRAMPROC piglit_CreateProgram;
-extern PFNGLCREATESHADERPROC piglit_CreateShader;
-extern PFNGLDELETEPROGRAMPROC piglit_DeleteProgram;
-extern PFNGLDELETESHADERPROC piglit_DeleteShader;
-extern PFNGLGETACTIVEUNIFORMPROC piglit_GetActiveUniform;
-extern PFNGLGETATTRIBLOCATIONPROC piglit_GetAttribLocation;
-extern PFNGLGETPROGRAMINFOLOGPROC piglit_GetProgramInfoLog;
-extern PFNGLGETPROGRAMIVPROC piglit_GetProgramiv;
-extern PFNGLGETSHADERINFOLOGPROC piglit_GetShaderInfoLog;
-extern PFNGLGETSHADERIVPROC piglit_GetShaderiv;
-extern PFNGLGETUNIFORMLOCATIONPROC piglit_GetUniformLocation;
-extern PFNGLLINKPROGRAMPROC piglit_LinkProgram;
-extern PFNGLSHADERSOURCEPROC piglit_ShaderSource;
-extern PFNGLUSEPROGRAMPROC piglit_UseProgram;
-extern PFNGLUNIFORM1FPROC piglit_Uniform1f;
-extern PFNGLUNIFORM2FPROC piglit_Uniform2f;
-extern PFNGLUNIFORM3FPROC piglit_Uniform3f;
-extern PFNGLUNIFORM4FPROC piglit_Uniform4f;
-extern PFNGLUNIFORM1FVPROC piglit_Uniform1fv;
-extern PFNGLUNIFORM2FVPROC piglit_Uniform2fv;
-extern PFNGLUNIFORM3FVPROC piglit_Uniform3fv;
-extern PFNGLUNIFORM4FVPROC piglit_Uniform4fv;
-extern PFNGLUNIFORM1IPROC piglit_Uniform1i;
-extern PFNGLUNIFORM2IPROC piglit_Uniform2i;
-extern PFNGLUNIFORM3IPROC piglit_Uniform3i;
-extern PFNGLUNIFORM4IPROC piglit_Uniform4i;
-extern PFNGLUNIFORM1IVPROC piglit_Uniform1iv;
-extern PFNGLUNIFORM2IVPROC piglit_Uniform2iv;
-extern PFNGLUNIFORM3IVPROC piglit_Uniform3iv;
-extern PFNGLUNIFORM4IVPROC piglit_Uniform4iv;
-extern PFNGLUNIFORM1UIPROC piglit_Uniform1ui;
-extern PFNGLUNIFORM2UIPROC piglit_Uniform2ui;
-extern PFNGLUNIFORM3UIPROC piglit_Uniform3ui;
-extern PFNGLUNIFORM4UIPROC piglit_Uniform4ui;
-extern PFNGLUNIFORM1UIVPROC piglit_Uniform1uiv;
-extern PFNGLUNIFORM2UIVPROC piglit_Uniform2uiv;
-extern PFNGLUNIFORM3UIVPROC piglit_Uniform3uiv;
-extern PFNGLUNIFORM4UIVPROC piglit_Uniform4uiv;
-extern PFNGLUNIFORMMATRIX2FVPROC piglit_UniformMatrix2fv;
-extern PFNGLUNIFORMMATRIX3FVPROC piglit_UniformMatrix3fv;
-extern PFNGLUNIFORMMATRIX4FVPROC piglit_UniformMatrix4fv;
-extern PFNGLGETUNIFORMFVPROC piglit_GetUniformfv;
-extern PFNGLVERTEXATTRIBPOINTERPROC piglit_VertexAttribPointer;
-extern PFNGLENABLEVERTEXATTRIBARRAYPROC piglit_EnableVertexAttribArray;
-extern PFNGLDISABLEVERTEXATTRIBARRAYPROC piglit_DisableVertexAttribArray;
-extern PFNGLUNIFORMMATRIX2X3FVPROC piglit_UniformMatrix2x3fv;
-extern PFNGLUNIFORMMATRIX2X4FVPROC piglit_UniformMatrix2x4fv;
-extern PFNGLUNIFORMMATRIX3X2FVPROC piglit_UniformMatrix3x2fv;
-extern PFNGLUNIFORMMATRIX3X4FVPROC piglit_UniformMatrix3x4fv;
-extern PFNGLUNIFORMMATRIX4X2FVPROC piglit_UniformMatrix4x2fv;
-extern PFNGLUNIFORMMATRIX4X3FVPROC piglit_UniformMatrix4x3fv;
+#define glAttachShader assert(!"glAttachShader does not exist in ES1")
+#define glBindAttribLocation assert(!"glBindAttribLocation does not exist in ES1")
+#define glCompileShader assert(!"glCompileShader does not exist in ES1")
+#define glCreateProgram assert(!"glCreateProgram does not exist in ES1")
+#define glCreateShader assert(!"glCreateShader does not exist in ES1")
+#define glDeleteProgram assert(!"glDeleteProgram does not exist in ES1")
+#define glDeleteShader assert(!"glDeleteShader does not exist in ES1")
+#define glGetActiveUniform assert(!"glGetActiveUniform does not exist in ES1")
+#define glGetAttribLocation assert(!"glGetAttribLocation does not exist in ES1")
+#define glGetProgramInfoLog assert(!"glGetProgramInfoLog does not exist in ES1")
+#define glGetProgramiv assert(!"glGetProgramiv does not exist in ES1")
+#define glGetShaderInfoLog assert(!"glGetShaderInfoLog does not exist in ES1")
+#define glGetShaderiv assert(!"glGetShaderiv does not exist in ES1")
+#define glGetUniformLocation assert(!"glGetUniformLocation does not exist in ES1")
+#define glLinkProgram assert(!"glLinkProgram does not exist in ES1")
+#define glShaderSource assert(!"glShaderSource does not exist in ES1")
+#define glUseProgram assert(!"glUseProgram does not exist in ES1")
+#define glUniform1f assert(!"glUniform1f does not exist in ES1")
+#define glUniform2f assert(!"glUniform2f does not exist in ES1")
+#define glUniform3f assert(!"glUniform3f does not exist in ES1")
+#define glUniform4f assert(!"glUniform4f does not exist in ES1")
+#define glUniform1fv assert(!"glUniform1fv does not exist in ES1")
+#define glUniform2fv assert(!"glUniform2fv does not exist in ES1")
+#define glUniform3fv assert(!"glUniform3fv does not exist in ES1")
+#define glUniform4fv assert(!"glUniform4fv does not exist in ES1")
+#define glUniform1i assert(!"glUniform1i does not exist in ES1")
+#define glUniform2iv assert(!"glUniform2iv does not exist in ES1")
+#define glUniform3iv assert(!"glUniform3iv does not exist in ES1")
+#define glUniform4iv assert(!"glUniform4iv does not exist in ES1")
+#define glUniformMatrix2fv assert(!"glUniformMatrix2fv does not exist in ES1")
+#define glUniformMatrix3fv assert(!"glUniformMatrix3fv does not exist in ES1")
+#define glUniformMatrix4fv assert(!"glUniformMatrix4fv does not exist in ES1")
+#define glGetUniformfv assert(!"glGetUniformfv does not exist in ES1")
+#define glVertexAttribPointer assert(!"glVertexAttribPointer does not exist in ES1")
+#define glEnableVertexAttribArray assert(!"glEnableVertexAttribArray does not exist in ES1")
+#define glDisableVertexAttribArray assert(!"glDisableVertexAttribArray does not exist in ES1")
+#define glUniformMatrix2x3fv assert(!"glUniformMatrix2x3fv does not exist in ES1")
+#define glUniformMatrix2x4fv assert(!"glUniformMatrix2x4fv does not exist in ES1")
+#define glUniformMatrix3x2fv assert(!"glUniformMatrix3x2fv does not exist in ES1")
+#define glUniformMatrix3x4fv assert(!"glUniformMatrix3x4fv does not exist in ES1")
+#define glUniformMatrix4x2fv assert(!"glUniformMatrix4x2fv does not exist in ES1")
+#define glUniformMatrix4x3fv assert(!"glUniformMatrix4x3fv does not exist in ES1")
+#elif defined(PIGLIT_USE_OPENGL_ES22)
+#define glUniformMatrix2x3fv assert(!"glUniformMatrix2x3fv does not exist in ES2")
+#define glUniformMatrix2x4fv assert(!"glUniformMatrix2x4fv does not exist in ES2")
+#define glUniformMatrix3x2fv assert(!"glUniformMatrix3x2fv does not exist in ES2")
+#define glUniformMatrix3x4fv assert(!"glUniformMatrix3x4fv does not exist in ES2")
+#define glUniformMatrix4x2fv assert(!"glUniformMatrix4x2fv does not exist in ES2")
+#define glUniformMatrix4x3fv assert(!"glUniformMatrix4x3fv does not exist in ES2")
 #endif
-/*@}*/
 
 /**
  * Require a specific version of GLSL.