Changed some states to enum; static gl_context for shader compiling/linking.

Changed language version from 100 to 120.

19 files changed, 517 insertions, 383 deletions

diff --git a/Android.mk b/Android.mk
index 929e42c..31e316f 100644
--- a/Android.mk
+++ b/Android.mk
@@ -101,6 +101,7 @@ libMesa_SRC_FILES :=	\
 	src/glsl/strtod.c \
 	src/glsl/ir_to_llvm.cpp \
 	src/glsl/ir_to_llvm_helper.cpp \
+	src/mesa/main/shaderobj.c \
 	src/mesa/program/hash_table.c \
 	src/mesa/program/prog_parameter.cpp \
 	src/mesa/program/symbol_table.c \
diff --git a/include/pixelflinger2/pixelflinger2_interface.h b/include/pixelflinger2/pixelflinger2_interface.h
index 3fa26b2..a141f36 100644
--- a/include/pixelflinger2/pixelflinger2_interface.h
+++ b/include/pixelflinger2/pixelflinger2_interface.h
@@ -25,8 +25,6 @@
 
 typedef struct gl_shader gl_shader_t;
 typedef struct gl_shader_program gl_shader_program_t;
-typedef struct gl_context gl_context_t;
-typedef struct GGLContext GGLContext_t;
 
 typedef struct VertexInput {
    Vector4 attributes[GGL_MAXVERTEXATTRIBS]; // vert input
@@ -73,17 +71,18 @@ typedef struct GGLTexture {
    void * levels;
 
    // the following affects vs/fs jit; must fit in byte; size used in GetShaderKey
-unsigned wrapS :
+   enum GGLTextureWrap {
+      GGL_REPEAT = 0, GGL_CLAMP_TO_EDGE = 1, GGL_MIRRORED_REPEAT = 2
+} wrapS :
 2, wrapT :
-   2; // GL_REPEAT = 0, GL_CLAMP_TO_EDGE = 1, GL_MIRRORED_REPEAT = 2
-
-   // GL_NEAREST = 0, GL_LINEAR, GL_NEAREST_MIPMAP_NEAREST = 2,
-   // GL_LINEAR_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR_MIPMAP_LINEAR = 5
-unsigned minFilter :
-   3;
-
-unsigned magFilter :
-   1; // GL_NEAREST = 0, GL_LINEAR
+   2;
+
+   enum GGLTextureMinFilter {
+      GGL_NEAREST = 0, GGL_LINEAR, /*GGL_NEAREST_MIPMAP_NEAREST = 2,
+      GGL_LINEAR_MIPMAP_NEAREST, GGL_NEAREST_MIPMAP_LINEAR, GGL_LINEAR_MIPMAP_LINEAR = 5*/
+} minFilter :
+1, magFilter :
+   1; // only GGL_NEAREST and GGL_LINEAR
 } GGLTexture_t;
 
 typedef struct GGLStencilState {
@@ -117,21 +116,25 @@ unsigned depthFunc :
 typedef struct GGLBlendState { // all values affect scanline jit
    unsigned char color[4]; // rgba[0,255]
 
-unsigned scf :
+   // value = 0,1 | GLenum - GL_SRC_COLOR + 2 | GLenum - GL_CONSTANT_COLOR + 11
+   enum GGLBlendFactor {
+      GGL_ZERO = 0, GGL_ONE, GGL_SRC_COLOR = 2, GGL_ONE_MINUS_SRC_COLOR, GGL_SRC_ALPHA, GGL_ONE_MINUS_SRC_ALPHA,
+      GGL_DST_ALPHA, GGL_ONE_MINUS_DST_ALPHA, GGL_DST_COLOR, GGL_ONE_MINUS_DST_COLOR,
+      GGL_SRC_ALPHA_SATURATE, GGL_CONSTANT_COLOR = 11, GGL_ONE_MINUS_CONSTANT_COLOR,
+      GGL_CONSTANT_ALPHA, GGL_ONE_MINUS_CONSTANT_ALPHA
+} scf :
 4, saf :
 4, dcf :
 4, daf :
-   4; // GL_ZERO = 0, GL_ONE, GL_SRC_COLOR = 2,
-   // GL_ONE_MINUS_SRC_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA,
-   // GL_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_COLOR,
-   // GL_SRC_ALPHA_SATURATE, GL_CONSTANT_COLOR = 11, GL_ONE_MINUS_CONSTANT_COLOR,
-   // GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA;
-   // value = 0,1 | GLenum - GL_SRC_COLOR + 2 | GLenum - GL_CONSTANT_COLOR + 11
+   4;
 
-unsigned ce :
+   //value = GLenum - GL_FUNC_ADD
+   enum GGLBlendFunc {
+      GGL_FUNC_ADD = 0, GGL_FUNC_SUBTRACT = 4,
+      GGL_FUNC_REVERSE_SUBTRACT = 5
+} ce :
 3, ae :
-   3; // GL_FUNC_ADD = 0, GL_FUNC_SUBTRACT = 4,
-   // GL_FUNC_REVERSE_SUBTRACT = 5; value = GLenum - GL_FUNC_ADD
+   3;
 
 unsigned enable :
    1;
@@ -217,7 +220,7 @@ struct GGLInterface {
 
    // creates empty shader
    gl_shader_t * (* ShaderCreate)(const GGLInterface_t * iface, GLenum type);
-   // compiles a shader given glsl; returns GL_TRUE on success; glsl only used during call; use infoLog to retrieve status
+   // compiles a shader given glsl; returns GL_TRUE on success; glsl only used during call
    GLboolean (* ShaderCompile)(const GGLInterface_t * iface, gl_shader_t * shader,
                                const char * glsl, const char ** infoLog);
 
@@ -227,14 +230,15 @@ struct GGLInterface {
    gl_shader_program_t * (* ShaderProgramCreate)(const GGLInterface_t * iface);
 
    // attaches a shader to program
-   void (* ShaderAttach)(const GGLInterface_t * iface, gl_shader_program_t * program, gl_shader_t * shader);
+   void (* ShaderAttach)(const GGLInterface_t * iface, gl_shader_program_t * program,
+                         gl_shader_t * shader);
 
    // detaches a shader from program
-   void (* ShaderDetach)(const GGLInterface_t * iface, gl_shader_program_t * program, gl_shader_t * shader);
+   void (* ShaderDetach)(const GGLInterface_t * iface, gl_shader_program_t * program,
+                         gl_shader_t * shader);
 
    // duplicates shaders to program, and links varyings / attributes
-   GLboolean (* ShaderProgramLink)(const GGLInterface_t * iface, gl_shader_program_t * program,
-                                   const char ** infoLog);
+   GLboolean (* ShaderProgramLink)(gl_shader_program_t * program, const char ** infoLog);
    // frees program
    void (* ShaderProgramDelete)(GGLInterface_t * iface, gl_shader_program_t * program);
 
@@ -279,7 +283,7 @@ extern "C"
    gl_shader_t * GGLShaderCreate(GLenum type);
 
    // compiles a shader given glsl; returns GL_TRUE on success; glsl only used during call; use infoLog to retrieve status
-   GLboolean GGLShaderCompile(const gl_context_t * glCtx, gl_shader_t * shader, const char * glsl, const char ** infoLog);
+   GLboolean GGLShaderCompile(gl_shader_t * shader, const char * glsl, const char ** infoLog);
 
    void GGLShaderDelete(gl_shader_t * shader);
 
@@ -293,12 +297,13 @@ extern "C"
    unsigned GGLShaderDetach(gl_shader_program_t * program, gl_shader_t * shader);
 
    // duplicates shaders to program, and links varyings / attributes;
-   GLboolean GGLShaderProgramLink(gl_context_t * glCtx, gl_shader_program_t * program, const char ** infoLog);
+   GLboolean GGLShaderProgramLink(gl_shader_program_t * program, const char ** infoLog);
+
    // frees program
    void GGLShaderProgramDelete(gl_shader_program_t * program);
 
    // LLVM JIT and set as active program, also call after gglState change to re-JIT
-   void GGLShaderUse(const GGLContext_t * gglCtx /*nullable*/, void * llvmCtx, const GGLState_t * gglState, gl_shader_program_t * program);
+   void GGLShaderUse(void * llvmCtx, const GGLState_t * gglState, gl_shader_program_t * program);
 
    // bind attribute location before linking
    void GGLShaderAttributeBind(const gl_shader_program_t * program,
diff --git a/libMesa.project b/libMesa.project
index 08a7dd4..4443805 100644
--- a/libMesa.project
+++ b/libMesa.project
@@ -58,6 +58,7 @@
         <File Name="src/mesa/main/context.h"/>
         <File Name="src/mesa/main/simple_list.h"/>
         <File Name="src/mesa/main/mtypes.h"/>
+        <File Name="src/mesa/main/shaderobj.c"/>
       </VirtualDirectory>
       <VirtualDirectory Name="program">
         <File Name="src/mesa/program/prog_parameter.cpp"/>
@@ -219,9 +220,11 @@
   </VirtualDirectory>
   <Description/>
   <Dependencies/>
+  <Dependencies Name="Release"/>
+  <Dependencies Name="Debug"/>
   <Settings Type="Static Library">
     <Configuration Name="Debug" CompilerType="gnu gcc" DebuggerType="GNU gdb debugger" Type="Static Library" BuildCmpWithGlobalSettings="append" BuildLnkWithGlobalSettings="append" BuildResWithGlobalSettings="append">
-      <Compiler Options="-g;-D__STDC_LIMIT_MACROS;-D__STDC_CONSTANT_MACROS;-m32 -march=i686;-DDEBUG;-UNDEBUG;-O0" Required="yes" PreCompiledHeader="">
+      <Compiler Options="-D__STDC_LIMIT_MACROS;-D__STDC_CONSTANT_MACROS;-m32 -march=i686;-DDEBUG;-UNDEBUG;-O0;-g" Required="yes" PreCompiledHeader="">
         <IncludePath Value="src/mesa/"/>
         <IncludePath Value="include/"/>
         <IncludePath Value="src/talloc/"/>
@@ -315,6 +318,4 @@
       <ResourceCompiler Options=""/>
     </GlobalSettings>
   </Settings>
-  <Dependencies Name="Debug"/>
-  <Dependencies Name="Release"/>
 </CodeLite_Project>
diff --git a/src/glsl/builtin_function.cpp b/src/glsl/builtin_function.cpp
index 9a5e001..1bfca3f 100644
--- a/src/glsl/builtin_function.cpp
+++ b/src/glsl/builtin_function.cpp
@@ -23,15 +23,12 @@
  */
 
 #include <stdio.h>
-#include "main/core.h" /* for struct gl_shader */
+#include "main/shaderobj.h" /* for struct gl_shader */
 #include "glsl_parser_extras.h"
 #include "ir_reader.h"
 #include "program.h"
 #include "ast.h"
 
-extern "C" struct gl_shader *
-_mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type);
-
 gl_shader *
 read_builtins(void * mem_ctx, GLenum target, const char *protos, const char **functions, unsigned count)
 {
diff --git a/src/glsl/glsl_parser_extras.cpp b/src/glsl/glsl_parser_extras.cpp
index 7c851ca..d9f52da 100644
--- a/src/glsl/glsl_parser_extras.cpp
+++ b/src/glsl/glsl_parser_extras.cpp
@@ -59,7 +59,7 @@ _mesa_glsl_parse_state::_mesa_glsl_parse_state(const struct gl_context *ctx,
 
    /* OpenGL ES 2.0 has different defaults from desktop GL. */
    if (ctx->API == API_OPENGLES2) {
-      this->language_version = 100;
+      this->language_version = 120;
       this->es_shader = true;
       this->ARB_texture_rectangle_enable = false;
    }
diff --git a/src/glsl/ir_to_llvm.cpp b/src/glsl/ir_to_llvm.cpp
index 0641569..5c8b2ff 100644
--- a/src/glsl/ir_to_llvm.cpp
+++ b/src/glsl/ir_to_llvm.cpp
@@ -914,19 +914,17 @@ public:
          sampler = deref->variable_referenced();
       else if(ir_dereference_array* deref = ir->sampler->as_dereference_array())
       {
-         result = llvm::Constant::getNullValue(llvm::VectorType::get(bld.getFloatTy(), 4));
+         assert(0); // not implemented
          return;
-         assert(0);
          deref->array_index;
          deref->array;
       }
       else if(ir->sampler->as_dereference())
       {
-         assert(0);
+         assert(0); // not implemented
          ir_dereference_record* deref = (ir_dereference_record*)ir->sampler;
          int idx = deref->record->type->field_index(deref->field);
          assert(idx >= 0);
-         //return bld.CreateConstInBoundsGEP2_32(llvm_pointer(deref->record), 0, idx);
       }
       else
          assert(0);
diff --git a/src/glsl/linker.cpp b/src/glsl/linker.cpp
index 0b6a125..e8f1497 100644
--- a/src/glsl/linker.cpp
+++ b/src/glsl/linker.cpp
@@ -82,11 +82,7 @@ extern "C" {
 #include "linker.h"
 #include "ir_optimization.h"
 
-extern "C" {
 #include "main/shaderobj.h"
-}
-
-extern "C" void _mesa_delete_shader(gl_context * ctx, gl_shader * shader);
 
 /**
  * Visitor that determines whether or not a variable is ever written.
@@ -763,7 +759,7 @@ get_main_function_signature(gl_shader *sh)
  */
 static struct gl_shader *
 link_intrastage_shaders(void *mem_ctx,
-			struct gl_context *ctx,
+			const struct gl_context *ctx,
 			struct gl_shader_program *prog,
 			struct gl_shader **shader_list,
 			unsigned num_shaders)
@@ -837,8 +833,7 @@ link_intrastage_shaders(void *mem_ctx,
       return NULL;
    }
 
-   gl_shader *linked = _mesa_new_shader(ctx, 0, main->Type);
-   hieralloc_steal(prog, linked);
+   gl_shader *linked = _mesa_new_shader(prog, 0, main->Type);
    linked->ir = new(linked) exec_list;
    clone_ir_list(mem_ctx, linked->ir, main->ir);
 
@@ -1533,7 +1528,7 @@ assign_varying_locations(struct gl_shader_program *prog,
 
 
 void
-link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
+link_shaders(const struct gl_context *ctx, struct gl_shader_program *prog)
 {
    //void *mem_ctx = hieralloc_init("temporary linker context");
    void * mem_ctx = prog; // need linked & cloned ir to persist 
diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
index 8dd73d1..5364b02 100644
--- a/src/mesa/main/mtypes.h
+++ b/src/mesa/main/mtypes.h
@@ -2628,32 +2628,32 @@ struct gl_constants
 
    GLuint MaxVarying;  /**< Number of float[4] varying parameters */
 
-   GLuint GLSLVersion;  /**< GLSL version supported (ex: 120 = 1.20) */
+//   GLuint GLSLVersion;  /**< GLSL version supported (ex: 120 = 1.20) */
 
-   /** Which texture units support GL_ATI_envmap_bumpmap as targets */
-   GLbitfield SupportedBumpUnits;
-
-   /**
-    * Maximum amount of time, measured in nanseconds, that the server can wait.
-    */
-   GLuint64 MaxServerWaitTimeout;
-
-   /** GL_EXT_provoking_vertex */
-   GLboolean QuadsFollowProvokingVertexConvention;
-
-   /** OpenGL version 3.0 */
-   GLbitfield ContextFlags;  /**< Ex: GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */
-
-   /** OpenGL version 3.2 */
-   GLbitfield ProfileMask;   /**< Mask of CONTEXT_x_PROFILE_BIT */
-
-   /** GL_EXT_transform_feedback */
-   GLuint MaxTransformFeedbackSeparateAttribs;
-   GLuint MaxTransformFeedbackSeparateComponents;
-   GLuint MaxTransformFeedbackInterleavedComponents;
-
-   /** GL_EXT_gpu_shader4 */
-   GLint MinProgramTexelOffset, MaxProgramTexelOffset;
+//   /** Which texture units support GL_ATI_envmap_bumpmap as targets */
+//   GLbitfield SupportedBumpUnits;
+//
+//   /**
+//    * Maximum amount of time, measured in nanseconds, that the server can wait.
+//    */
+//   GLuint64 MaxServerWaitTimeout;
+//
+//   /** GL_EXT_provoking_vertex */
+//   GLboolean QuadsFollowProvokingVertexConvention;
+//
+//   /** OpenGL version 3.0 */
+//   GLbitfield ContextFlags;  /**< Ex: GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT */
+//
+//   /** OpenGL version 3.2 */
+//   GLbitfield ProfileMask;   /**< Mask of CONTEXT_x_PROFILE_BIT */
+//
+//   /** GL_EXT_transform_feedback */
+//   GLuint MaxTransformFeedbackSeparateAttribs;
+//   GLuint MaxTransformFeedbackSeparateComponents;
+//   GLuint MaxTransformFeedbackInterleavedComponents;
+//
+//   /** GL_EXT_gpu_shader4 */
+//   GLint MinProgramTexelOffset, MaxProgramTexelOffset;
 };
 
 
diff --git a/src/mesa/main/shaderobj.c b/src/mesa/main/shaderobj.c
new file mode 100644
index 0000000..4fc572c
--- /dev/null
+++ b/src/mesa/main/shaderobj.c
@@ -0,0 +1,44 @@
+#include <stdlib.h>
+#include <assert.h>
+
+#include <GLES2/gl2.h>
+
+#include <src/mesa/main/mtypes.h>
+
+void _mesa_reference_shader(const void * ctx, struct gl_shader **ptr,
+                                          struct gl_shader *sh)
+{
+   *ptr = sh;
+}
+
+static struct gl_shader * (watches[20]) = {0};
+static unsigned watch = 0;
+
+struct gl_shader * _mesa_new_shader(const void * ctx, GLuint name, GLenum type)
+{
+   assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER);
+   struct gl_shader * shader = (struct gl_shader *)_hieralloc_zero(ctx, sizeof(struct gl_shader), "zr:gl_shader");
+   if (shader) {
+      shader->Type = type;
+      shader->Name = name;
+      shader->RefCount = 1;
+   }
+   if (!ctx)
+      watches[watch++] = shader;
+   return shader;
+}
+
+void _mesa_delete_shader(const void * ctx, struct gl_shader *shader)
+{
+   if (!shader)
+      return;
+   if (shader->RefCount > 1) {
+      shader->DeletePending = GL_TRUE;
+      return;
+   }
+   unsigned i = 0;
+   for (i = 0; i < watch; i++)
+      if (watches[i] == shader)
+         watches[i] = watches[--watch];
+   hieralloc_free(shader);
+}
\ No newline at end of file
diff --git a/src/mesa/main/shaderobj.h b/src/mesa/main/shaderobj.h
index de7c998..683b70b 100644
--- a/src/mesa/main/shaderobj.h
+++ b/src/mesa/main/shaderobj.h
@@ -39,95 +39,98 @@ extern "C" {
  * Internal functions
  */
 
+//extern void
+//_mesa_init_shader_state(struct gl_context * ctx);
+//
+//extern void
+//_mesa_free_shader_state(struct gl_context *ctx);
+//
+//
 extern void
-_mesa_init_shader_state(struct gl_context * ctx);
-
-extern void
-_mesa_free_shader_state(struct gl_context *ctx);
-
-
-extern void
-_mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,
+_mesa_reference_shader(const void * ctx, struct gl_shader **ptr,
                        struct gl_shader *sh);
+//
+//extern struct gl_shader *
+//_mesa_lookup_shader(struct gl_context *ctx, GLuint name);
+//
+//extern struct gl_shader *
+//_mesa_lookup_shader_err(struct gl_context *ctx, GLuint name, const char *caller);
+//
+//
+//
+//extern void
+//_mesa_reference_shader_program(struct gl_context *ctx,
+//                               struct gl_shader_program **ptr,
+//                               struct gl_shader_program *shProg);
+//extern void
+//_mesa_init_shader(struct gl_context *ctx, struct gl_shader *shader);
 
 extern struct gl_shader *
-_mesa_lookup_shader(struct gl_context *ctx, GLuint name);
+_mesa_new_shader(const void * ctx, GLuint name, GLenum type);
 
 extern struct gl_shader *
-_mesa_lookup_shader_err(struct gl_context *ctx, GLuint name, const char *caller);
-
-
-
-extern void
-_mesa_reference_shader_program(struct gl_context *ctx,
-                               struct gl_shader_program **ptr,
-                               struct gl_shader_program *shProg);
-extern void
-_mesa_init_shader(struct gl_context *ctx, struct gl_shader *shader);
-
-extern struct gl_shader *
-_mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type);
-
-extern void
-_mesa_init_shader_program(struct gl_context *ctx, struct gl_shader_program *prog);
-
-extern struct gl_shader_program *
-_mesa_lookup_shader_program(struct gl_context *ctx, GLuint name);
-
-extern struct gl_shader_program *
-_mesa_lookup_shader_program_err(struct gl_context *ctx, GLuint name,
-                                const char *caller);
-
-extern void
-_mesa_clear_shader_program_data(struct gl_context *ctx,
-                                struct gl_shader_program *shProg);
-
-extern void
-_mesa_free_shader_program_data(struct gl_context *ctx,
-                               struct gl_shader_program *shProg);
-
-
-
-extern void
-_mesa_init_shader_object_functions(struct dd_function_table *driver);
-
-extern void
-_mesa_init_shader_state(struct gl_context *ctx);
-
-extern void
-_mesa_free_shader_state(struct gl_context *ctx);
-
-
-static INLINE gl_shader_type
-_mesa_shader_type_to_index(GLenum v)
-{
-   switch (v) {
-   case GL_VERTEX_SHADER:
-      return MESA_SHADER_VERTEX;
-   case GL_FRAGMENT_SHADER:
-      return MESA_SHADER_FRAGMENT;
-   case GL_GEOMETRY_SHADER:
-      return MESA_SHADER_GEOMETRY;
-   default:
-      ASSERT(0 && "bad value in _mesa_shader_type_to_index()");
-      return MESA_SHADER_TYPES;
-   }
-}
-
-
-static INLINE GLenum
-_mesa_shader_index_to_type(GLuint i)
-{
-   static const GLenum enums[MESA_SHADER_TYPES] = {
-      GL_VERTEX_SHADER,
-      GL_FRAGMENT_SHADER,
-      GL_GEOMETRY_SHADER ,
-   };
-   if (i >= MESA_SHADER_TYPES)
-      return 0;
-   else
-      return enums[i];
-}
+_mesa_delete_shader(const void * ctx, struct gl_shader * shader);
+
+//extern void
+//_mesa_init_shader_program(struct gl_context *ctx, struct gl_shader_program *prog);
+//
+//extern struct gl_shader_program *
+//_mesa_lookup_shader_program(struct gl_context *ctx, GLuint name);
+//
+//extern struct gl_shader_program *
+//_mesa_lookup_shader_program_err(struct gl_context *ctx, GLuint name,
+//                                const char *caller);
+//
+//extern void
+//_mesa_clear_shader_program_data(struct gl_context *ctx,
+//                                struct gl_shader_program *shProg);
+//
+//extern void
+//_mesa_free_shader_program_data(struct gl_context *ctx,
+//                               struct gl_shader_program *shProg);
+//
+//
+//
+//extern void
+//_mesa_init_shader_object_functions(struct dd_function_table *driver);
+//
+//extern void
+//_mesa_init_shader_state(struct gl_context *ctx);
+//
+//extern void
+//_mesa_free_shader_state(struct gl_context *ctx);
+
+
+//static INLINE gl_shader_type
+//_mesa_shader_type_to_index(GLenum v)
+//{
+//   switch (v) {
+//   case GL_VERTEX_SHADER:
+//      return MESA_SHADER_VERTEX;
+//   case GL_FRAGMENT_SHADER:
+//      return MESA_SHADER_FRAGMENT;
+//   case GL_GEOMETRY_SHADER:
+//      return MESA_SHADER_GEOMETRY;
+//   default:
+//      ASSERT(0 && "bad value in _mesa_shader_type_to_index()");
+//      return MESA_SHADER_TYPES;
+//   }
+//}
+//
+//
+//static INLINE GLenum
+//_mesa_shader_index_to_type(GLuint i)
+//{
+//   static const GLenum enums[MESA_SHADER_TYPES] = {
+//      GL_VERTEX_SHADER,
+//      GL_FRAGMENT_SHADER,
+//      GL_GEOMETRY_SHADER ,
+//   };
+//   if (i >= MESA_SHADER_TYPES)
+//      return 0;
+//   else
+//      return enums[i];
+//}
 
 
 #ifdef __cplusplus
diff --git a/src/pixelflinger2/pixelflinger2.cpp b/src/pixelflinger2/pixelflinger2.cpp
index 2eb419d..eee0d95 100644
--- a/src/pixelflinger2/pixelflinger2.cpp
+++ b/src/pixelflinger2/pixelflinger2.cpp
@@ -83,8 +83,8 @@ static void BlendEquationSeparate(GGLInterface * iface, GLenum modeRGB, GLenum m
    if (GL_FUNC_ADD != modeRGB && (GL_FUNC_SUBTRACT > modeRGB ||
                                   GL_FUNC_REVERSE_SUBTRACT < modeRGB))
       return gglError(GL_INVALID_ENUM);
-   ctx->state.blendState.ce = modeRGB - GL_FUNC_ADD;
-   ctx->state.blendState.ae = modeAlpha - GL_FUNC_ADD;
+   ctx->state.blendState.ce = (GGLBlendState::GGLBlendFunc)(modeRGB - GL_FUNC_ADD);
+   ctx->state.blendState.ae = (GGLBlendState::GGLBlendFunc)(modeAlpha - GL_FUNC_ADD);
    SetShaderVerifyFunctions(iface);
 }
 
@@ -111,21 +111,21 @@ static void BlendFuncSeparate(GGLInterface * iface, GLenum srcRGB, GLenum dstRGB
       srcAlpha = GL_ONE;
    // in c++ it's templated function for color and alpha,
    // so it requires setting srcAlpha to GL_ONE to run template again only for alpha
-   ctx->state.blendState.scf = srcRGB <= GL_ONE ? srcRGB :
+   ctx->state.blendState.scf = (GGLBlendState::GGLBlendFactor)(srcRGB <= GL_ONE ? srcRGB :
                          (srcRGB <= GL_SRC_ALPHA_SATURATE ? srcRGB - GL_SRC_COLOR + 2
-                          : srcRGB - GL_CONSTANT_COLOR + 11);
+                          : srcRGB - GL_CONSTANT_COLOR + 11));
 
-   ctx->state.blendState.saf = srcAlpha <= GL_ONE ? srcAlpha :
+   ctx->state.blendState.saf = (GGLBlendState::GGLBlendFactor)(srcAlpha <= GL_ONE ? srcAlpha :
                          (srcAlpha <= GL_SRC_ALPHA_SATURATE ? srcAlpha - GL_SRC_COLOR + 2
-                          : srcAlpha - GL_CONSTANT_COLOR + 11);
+                          : srcAlpha - GL_CONSTANT_COLOR + 11));
 
-   ctx->state.blendState.dcf = dstRGB <= GL_ONE ? dstRGB :
+   ctx->state.blendState.dcf = (GGLBlendState::GGLBlendFactor)(dstRGB <= GL_ONE ? dstRGB :
                          (dstRGB <= GL_SRC_ALPHA_SATURATE ? dstRGB - GL_SRC_COLOR + 2
-                          : dstRGB - GL_CONSTANT_COLOR + 11);
+                          : dstRGB - GL_CONSTANT_COLOR + 11));
 
-   ctx->state.blendState.daf = dstAlpha <= GL_ONE ? dstAlpha :
+   ctx->state.blendState.daf = (GGLBlendState::GGLBlendFactor)(dstAlpha <= GL_ONE ? dstAlpha :
                          (dstAlpha <= GL_SRC_ALPHA_SATURATE ? dstAlpha - GL_SRC_COLOR + 2
-                          : dstAlpha - GL_CONSTANT_COLOR + 11);
+                          : dstAlpha - GL_CONSTANT_COLOR + 11));
 
    SetShaderVerifyFunctions(iface);
 
@@ -225,8 +225,6 @@ void DestroyGGLInterface(GGLInterface * iface)
 
    DestroyShaderFunctions(iface);
 
-   ctx->glCtx = NULL;
-
    free(ctx);
    
 #if USE_LLVM_TEXTURE_SAMPLER
diff --git a/src/pixelflinger2/pixelflinger2.h b/src/pixelflinger2/pixelflinger2.h
index 007954a..3d68d13 100644
--- a/src/pixelflinger2/pixelflinger2.h
+++ b/src/pixelflinger2/pixelflinger2.h
@@ -60,7 +60,6 @@ struct GGLContext {
    GGLSurface depthSurface;
    GGLSurface stencilSurface;
 
-   struct gl_context * glCtx; // hieralloc; mesa constants and others used for shader compiling and executing
    llvm::LLVMContext * llvmCtx;
 
    struct {
diff --git a/src/pixelflinger2/raster.cpp b/src/pixelflinger2/raster.cpp
index c2db172..74fdc19 100644
--- a/src/pixelflinger2/raster.cpp
+++ b/src/pixelflinger2/raster.cpp
@@ -53,8 +53,8 @@ static inline void InterpolateVertex(const VertexOutput * a, const VertexOutput
 
 }
 
-void GGLProcessVertex(const gl_shader_program * program, const VertexInput_t * input,
-                         VertexOutput_t * output, const float (*constants)[4])
+void GGLProcessVertex(const gl_shader_program * program, const VertexInput * input,
+                         VertexOutput * output, const float (*constants)[4])
 {
    ShaderFunction_t function = (ShaderFunction_t)program->_LinkedShaders[MESA_SHADER_VERTEX]->function;
    function(input, output, constants);
diff --git a/src/pixelflinger2/shader.cpp b/src/pixelflinger2/shader.cpp
index 87af237..2f6be4b 100644
--- a/src/pixelflinger2/shader.cpp
+++ b/src/pixelflinger2/shader.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2010 The Android Open Source Project
+ * Copyright (C) 2011 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,12 +27,65 @@
 
 
 #include "src/talloc/hieralloc.h"
-#include "src/mesa/main/mtypes.h"
+#include "src/mesa/main/shaderobj.h"
 #include "src/mesa/program/prog_parameter.h"
 #include "src/mesa/program/prog_uniform.h"
 #include "src/glsl/glsl_types.h"
 #include "src/glsl/ir_to_llvm.h"
 
+static void InitializeGLContext(struct gl_context *ctx)
+{
+   memset(ctx, 0, sizeof(*ctx));
+   ctx->API = API_OPENGLES2;
+   ctx->Extensions.ARB_draw_buffers = GL_TRUE;
+   ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
+   ctx->Extensions.EXT_texture_array = GL_TRUE;
+   ctx->Extensions.NV_texture_rectangle = GL_TRUE;
+
+   /* 1.10 minimums. */
+   ctx->Const.MaxLights = 8;
+   ctx->Const.MaxClipPlanes = 8;
+   ctx->Const.MaxTextureUnits = 2;
+
+   /* More than the 1.10 minimum to appease parser tests taken from
+    * apps that (hopefully) already checked the number of coords.
+    */
+   ctx->Const.MaxTextureCoordUnits = 4;
+
+   ctx->Const.VertexProgram.MaxAttribs = 16;
+   ctx->Const.VertexProgram.MaxUniformComponents = 512;
+   ctx->Const.MaxVarying = 8;
+   ctx->Const.MaxVertexTextureImageUnits = 0;
+   ctx->Const.MaxCombinedTextureImageUnits = 2;
+   ctx->Const.MaxTextureImageUnits = 2;
+   ctx->Const.FragmentProgram.MaxUniformComponents = 64;
+
+   ctx->Const.MaxDrawBuffers = 2;
+}
+
+static const struct GLContext {
+   const gl_context * ctx;
+   GLContext() {
+      ctx = hieralloc_zero(NULL, gl_context);
+//      ctx = (const gl_context*)calloc(1,sizeof(gl_context));
+      InitializeGLContext(const_cast<gl_context *>(ctx));
+   }
+   ~GLContext() {
+      _mesa_glsl_release_types(); // TODO: find when to release to minize memory
+      _mesa_glsl_release_functions(); // the IR has pointers to types
+      hieralloc_free(const_cast<gl_context *>(ctx));
+//      free(const_cast<gl_context *>(ctx));
+      ctx = NULL;
+   }
+} glContext;
+
+void GLContextDctr()
+{
+   _mesa_glsl_release_types(); // TODO: find when to release to minize memory
+   _mesa_glsl_release_functions();
+   //glContext.~GLContext();
+}
+
 struct ShaderKey {
    struct ScanLineKey {
       GGLStencilState frontStencil, backStencil;
@@ -65,46 +118,10 @@ struct Executable { // codegen info
 
 bool do_mat_op_to_vec(exec_list *instructions);
 
-extern void link_shaders(struct gl_context *ctx, struct gl_shader_program *prog);
+extern void link_shaders(const struct gl_context *ctx, struct gl_shader_program *prog);
 
 extern "C" void compile_shader(const struct gl_context *ctx, struct gl_shader *shader);
 
-extern "C" void _mesa_reference_shader(struct gl_context *ctx, struct gl_shader **ptr,
-                                          struct gl_shader *sh)
-{
-   *ptr = sh;
-}
-
-extern "C" gl_shader * _mesa_new_shader(struct gl_context *ctx, GLuint name, GLenum type)
-{
-   struct gl_shader *shader;
-   assert(type == GL_FRAGMENT_SHADER || type == GL_VERTEX_SHADER);
-   shader = hieralloc_zero(ctx, struct gl_shader);
-   if (shader) {
-      shader->Type = type;
-      shader->Name = name;
-      shader->RefCount = 1;
-   }
-   return shader;
-}
-
-extern "C" void _mesa_delete_shader(struct gl_context *ctx, struct gl_shader *shader)
-{
-   if (!shader)
-      return;
-   if (shader->RefCount > 1) {
-      shader->DeletePending = true;
-      return;
-   }
-   if (shader->executable) {
-      for (std::map<ShaderKey, Instance *>::iterator it=shader->executable->instances.begin();
-            it != shader->executable->instances.end(); it++)
-         (*it).second->~Instance();
-      shader->executable->instances.~map();
-   }
-   hieralloc_free(shader);
-}
-
 gl_shader * GGLShaderCreate(GLenum type)
 {
    return _mesa_new_shader(NULL, 0, type);
@@ -117,18 +134,17 @@ static gl_shader * ShaderCreate(const GGLInterface * iface, GLenum type)
       gglError(GL_INVALID_ENUM);
       return NULL;
    }
-   gl_shader * shader = _mesa_new_shader(ctx->glCtx, 0, type);
+   gl_shader * shader = _mesa_new_shader(NULL, 0, type);
    if (!shader)
       gglError(GL_OUT_OF_MEMORY);
    assert(1 == shader->RefCount);
    return shader;
 }
 
-GLboolean GGLShaderCompile(const gl_context * glCtx, gl_shader * shader,
-                           const char * glsl, const char ** infoLog)
+GLboolean GGLShaderCompile(gl_shader * shader, const char * glsl, const char ** infoLog)
 {
    shader->Source = glsl;
-   compile_shader(glCtx, shader);
+   compile_shader(glContext.ctx, shader);
    shader->Source = NULL;
    if (infoLog)
       *infoLog = shader->InfoLog;
@@ -143,18 +159,23 @@ static GLboolean ShaderCompile(const GGLInterface * iface, gl_shader * shader,
       gglError(GL_INVALID_VALUE);
       return GL_FALSE;
    }
-   return GGLShaderCompile(ctx->glCtx, shader, glsl, infoLog);
+   return GGLShaderCompile(shader, glsl, infoLog);
 }
 
 void GGLShaderDelete(gl_shader * shader)
 {
+   if (shader && shader->executable) {
+      for (std::map<ShaderKey, Instance *>::iterator it=shader->executable->instances.begin();
+            it != shader->executable->instances.end(); it++)
+         (*it).second->~Instance();
+      shader->executable->instances.~map();
+   }
    _mesa_delete_shader(NULL, shader);
 }
 
 static void ShaderDelete(const GGLInterface * iface, gl_shader * shader)
 {
-   GGL_GET_CONST_CONTEXT(ctx, iface);
-   _mesa_delete_shader(ctx->glCtx, shader);
+   GGLShaderDelete(shader);
 }
 
 gl_shader_program * GGLShaderProgramCreate()
@@ -178,23 +199,9 @@ gl_shader_program * GGLShaderProgramCreate()
 static gl_shader_program * ShaderProgramCreate(const GGLInterface * iface)
 {
    GGL_GET_CONST_CONTEXT(ctx, iface);
-   gl_shader_program * program = hieralloc_zero(ctx->glCtx, struct gl_shader_program);
-   if (!program) {
-      gglError(GL_OUT_OF_MEMORY);
-      return NULL;
-   }
-   program->Attributes = hieralloc_zero(program, gl_program_parameter_list);
-   if (!program->Attributes) {
-      hieralloc_free(program);
-      gglError(GL_OUT_OF_MEMORY);
-      return NULL;
-   }
-   program->Varying = hieralloc_zero(program, gl_program_parameter_list);
-   if (!program->Varying) {
-      hieralloc_free(program);
-      gglError(GL_OUT_OF_MEMORY);
-      return NULL;
-   }
+   gl_shader_program * program = GGLShaderProgramCreate();
+   if (!program)
+      gglError(GL_OUT_OF_MEMORY);   
    return program;
 }
 
@@ -224,32 +231,9 @@ static void ShaderAttach(const GGLInterface * iface, gl_shader_program * program
       gglError(error);
 }
 
-unsigned GGLShaderDetach(gl_shader_program * program, gl_shader * shader)
+GLboolean GGLShaderProgramLink(gl_shader_program * program, const char ** infoLog)
 {
-   for (unsigned i = 0; i < program->NumShaders; i++)
-      if (program->Shaders[i] == shader) {
-         program->NumShaders--;
-         program->Shaders[i] = program->Shaders[program->NumShaders];
-         shader->RefCount--;
-         if (1 == shader->RefCount && shader->DeletePending)
-            GGLShaderDelete(shader);
-         return GL_NO_ERROR;
-      }
-   return (GL_INVALID_OPERATION);
-}
-
-static void ShaderDetach(const GGLInterface * iface, gl_shader_program * program,
-                         gl_shader * shader)
-{
-   unsigned error = GGLShaderDetach(program, shader);
-   if (GL_NO_ERROR != error)
-      gglError(error);
-}
-
-GLboolean GGLShaderProgramLink(gl_context * glCtx, gl_shader_program * program,
-                               const char ** infoLog)
-{
-   link_shaders(glCtx, program);
+   link_shaders(glContext.ctx, program);
    if (infoLog)
       *infoLog = program->InfoLog;
    if (!program->LinkStatus)
@@ -268,11 +252,10 @@ GLboolean GGLShaderProgramLink(gl_context * glCtx, gl_shader_program * program,
    }
    return program->LinkStatus;
 }
-static GLboolean ShaderProgramLink(const GGLInterface * iface, gl_shader_program * program,
-                                   const char ** infoLog)
+
+static GLboolean ShaderProgramLink(gl_shader_program * program, const char ** infoLog)
 {
-   GGL_GET_CONST_CONTEXT(ctx, iface);
-   return GGLShaderProgramLink(ctx->glCtx, program, infoLog);
+   return GGLShaderProgramLink(program, infoLog);
 }
 
 static void GetShaderKey(const GGLState * ctx, const gl_shader * shader, ShaderKey * key)
@@ -367,32 +350,8 @@ static void* SymbolLookup(void* pContext, const char* name)
          symbol = (void *)gglCtx->textureState.textureData;
       else if (!strcmp(_PF2_TEXTURE_DIMENSIONS_NAME_, name))
          symbol = (void *)gglCtx->textureState.textureDimensions;
-      else {
-         for (unsigned i = 0; i < program->Uniforms->NumUniforms && !symbol; i++)
-            if (!strcmp(program->Uniforms->Uniforms[i].Name, name))
-               symbol = program->ValuesUniform + program->Uniforms->Uniforms[i].Pos;
-         for (unsigned i = 0; i < program->Attributes->NumParameters && !symbol; i++)
-            if (!strcmp(program->Attributes->Parameters[i].Name, name)) {
-               assert(program->Attributes->Parameters[i].Location
-                      < sizeof(VertexInput) / sizeof(float[4]));
-               symbol = program->ValuesVertexInput + program->Attributes->Parameters[i].Location;
-            }
-         for (unsigned i = 0; i < program->Varying->NumParameters && !symbol; i++)
-            if (!strcmp(program->Varying->Parameters[i].Name, name)) {
-               int index = -1;
-               if (GL_VERTEX_SHADER == shader->Type)
-                  index = program->Varying->Parameters[i].BindLocation;
-               else if (GL_FRAGMENT_SHADER == shader->Type)
-                  index = program->Varying->Parameters[i].Location;
-               else
-                  assert(0);
-               assert(index >= 0);
-               assert(index < sizeof(VertexOutput) / sizeof(float[4]));
-               symbol = program->ValuesVertexOutput + index;
-            }
-         assert(symbol >= program->ValuesVertexInput &&
-                symbol < (char *)program->ValuesUniform + 16 * program->Uniforms->Slots - 3);
-      };
+      else // attributes, varyings and uniforms are mapped to locations in pointers
+         assert(0);
    }
    printf("symbolLookup '%s'=%p \n", name, symbol);
    assert(symbol);
@@ -432,12 +391,13 @@ static void CodeGen(Instance * instance, const char * mainName, gl_shader * shad
 void GenerateScanLine(const GGLState * gglCtx, const gl_shader_program * program, llvm::Module * mod,
                       const char * shaderName, const char * scanlineName);
 
-void GGLShaderUse(const GGLContext * gglCtx, void * llvmCtx, const GGLState * gglState, gl_shader_program * program)
+void GGLShaderUse(void * llvmCtx, const GGLState * gglState, gl_shader_program * program)
 {
    for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
       if (!program->_LinkedShaders[i])
          continue;
       gl_shader * shader = program->_LinkedShaders[i];
+      shader->function = NULL;
       if (!shader->executable) {
          shader->executable = hieralloc_zero(shader, Executable);
          shader->executable->instances = std::map<ShaderKey, Instance *>();
@@ -457,7 +417,7 @@ void GGLShaderUse(const GGLContext * gglCtx, void * llvmCtx, const GGLState * gg
          char mainName [SHADER_KEY_STRING_LEN + 6] = {"main"};
          strcat(mainName, shaderName);
 
-         do_mat_op_to_vec(shader->ir);
+         do_mat_op_to_vec(shader->ir); // TODO: move these passes to link?
 
          llvm::Module * module = glsl_ir_to_llvm_module(shader->ir, instance->module, gglState, shaderName);
          if (!module)
@@ -478,42 +438,71 @@ void GGLShaderUse(const GGLContext * gglCtx, void * llvmCtx, const GGLState * gg
          ;
 
       shader->function  = instance->function;
-
-      if (gglCtx)
-         if (GL_VERTEX_SHADER == shader->Type)
-            gglCtx->PickRaster((GGLInterface *)gglCtx);
-         else if (GL_FRAGMENT_SHADER == shader->Type)
-            gglCtx->PickScanLine((GGLInterface *)gglCtx);
-         else
-            assert(0);
    }
 }
 
 static void ShaderUse(GGLInterface * iface, gl_shader_program * program)
 {
    GGL_GET_CONTEXT(ctx, iface);
-   assert(program);
+   // so drawing calls will do nothing until ShaderUse with a program
+   SetShaderVerifyFunctions(iface);
    if (!program) {
       ctx->CurrentProgram = NULL;
-      // so drawing calls will do nothing until ShaderUse with a program
-      SetShaderVerifyFunctions(iface);
       return;
    }
 
-   GGLShaderUse(ctx, ctx->llvmCtx, &ctx->state, program);
+   GGLShaderUse(ctx->llvmCtx, &ctx->state, program);
+   for (unsigned i = 0; i < MESA_SHADER_TYPES; i++) {
+      if (!program->_LinkedShaders[i])
+         continue;
+      if (!program->_LinkedShaders[i]->function)
+         continue;
+      if (GL_VERTEX_SHADER == program->_LinkedShaders[i]->Type)
+         ctx->PickRaster(iface);
+      else if (GL_FRAGMENT_SHADER == program->_LinkedShaders[i]->Type)
+         ctx->PickScanLine(iface);
+      else
+         assert(0);
+   }
 
    ctx->CurrentProgram = program;
 }
 
+unsigned GGLShaderDetach(gl_shader_program * program, gl_shader * shader)
+{
+   for (unsigned i = 0; i < program->NumShaders; i++)
+      if (program->Shaders[i] == shader) {
+         program->NumShaders--;
+         // just swap end to deleted shader
+         program->Shaders[i] = program->Shaders[program->NumShaders];
+         shader->RefCount--;
+         if (1 == shader->RefCount && shader->DeletePending)
+            GGLShaderDelete(shader);
+         return GL_NO_ERROR;
+      }
+   return (GL_INVALID_OPERATION);
+}
+
+static void ShaderDetach(const GGLInterface * iface, gl_shader_program * program,
+                         gl_shader * shader)
+{
+   unsigned error = GGLShaderDetach(program, shader);
+   if (GL_NO_ERROR != error)
+      gglError(error);
+}
+
 void GGLShaderProgramDelete(gl_shader_program * program)
 {
    for (unsigned i = 0; i < program->NumShaders; i++) {
-      GGLShaderDelete(program->Shaders[i]);
-      GGLShaderDetach(program, program->Shaders[i]);
+      GGLShaderDelete(program->Shaders[i]); // actually just mark for delete
+      GGLShaderDetach(program, program->Shaders[i]); // detach will delete if ref == 1
+      i--; // GGLShaderDetach just swaps end to detached shader
    }
 
    for (unsigned i = 0; i < MESA_SHADER_TYPES; i++)
       GGLShaderDelete(program->_LinkedShaders[i]);
+      
+   hieralloc_free(program);
 }
 
 static void ShaderProgramDelete(GGLInterface * iface, gl_shader_program * program)
@@ -521,9 +510,8 @@ static void ShaderProgramDelete(GGLInterface * iface, gl_shader_program * progra
    GGL_GET_CONTEXT(ctx, iface);
    if (ctx->CurrentProgram == program) {
       ctx->CurrentProgram = NULL;
-      SetShaderVerifyFunctions(const_cast<GGLInterface *>(iface));
+      SetShaderVerifyFunctions(iface);
    }
-
    GGLShaderProgramDelete(program);
 }
 
@@ -626,7 +614,8 @@ void GGLShaderUniformMatrix(gl_shader_program * program, GLint cols, GLint rows,
    if (location == -1)
       return;
    assert(cols == rows);
-   int start = location, slots = cols * count;
+   int start = location;
+   unsigned slots = cols * count;
    if (start < 0 || start + slots > program->Uniforms->Slots)
       return gglError(GL_INVALID_OPERATION);
    for (unsigned i = 0; i < slots; i++) {
@@ -702,42 +691,10 @@ void SetShaderVerifyFunctions(struct GGLInterface * iface)
    iface->ScanLine = ShaderVerifyScanLine;
 }
 
-static void InitializeGLContext(struct gl_context *ctx)
-{
-   memset(ctx, 0, sizeof(*ctx));
-   ctx->API = API_OPENGLES2;
-   ctx->Extensions.ARB_draw_buffers = GL_TRUE;
-   ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
-   ctx->Extensions.EXT_texture_array = GL_TRUE;
-   ctx->Extensions.NV_texture_rectangle = GL_TRUE;
-
-   /* 1.10 minimums. */
-   ctx->Const.MaxLights = 8;
-   ctx->Const.MaxClipPlanes = 8;
-   ctx->Const.MaxTextureUnits = 2;
-
-   /* More than the 1.10 minimum to appease parser tests taken from
-    * apps that (hopefully) already checked the number of coords.
-    */
-   ctx->Const.MaxTextureCoordUnits = 4;
-
-   ctx->Const.VertexProgram.MaxAttribs = 16;
-   ctx->Const.VertexProgram.MaxUniformComponents = 512;
-   ctx->Const.MaxVarying = 8;
-   ctx->Const.MaxVertexTextureImageUnits = 0;
-   ctx->Const.MaxCombinedTextureImageUnits = 2;
-   ctx->Const.MaxTextureImageUnits = 2;
-   ctx->Const.FragmentProgram.MaxUniformComponents = 64;
-
-   ctx->Const.MaxDrawBuffers = 2;
-}
-
 void InitializeShaderFunctions(struct GGLInterface * iface)
 {
    GGL_GET_CONTEXT(ctx, iface);
    ctx->llvmCtx = new llvm::LLVMContext();
-   ctx->glCtx = hieralloc(NULL, gl_context);
-   InitializeGLContext(ctx->glCtx);
 
    iface->ShaderCreate = ShaderCreate;
    iface->ShaderCompile = ShaderCompile;
@@ -763,6 +720,6 @@ void DestroyShaderFunctions(GGLInterface * iface)
    GGL_GET_CONTEXT(ctx, iface);
    _mesa_glsl_release_types();
    _mesa_glsl_release_functions();
-   hieralloc_free(ctx->glCtx);
    delete ctx->llvmCtx;
+   ctx->llvmCtx = NULL;
 }
diff --git a/test/Android.mk b/test/Android.mk
index 593d163..4776c3d 100644
--- a/test/Android.mk
+++ b/test/Android.mk
@@ -3,6 +3,7 @@ DEBUG_BUILD := true
 ifneq ($(TARGET_SIMULATOR),true)
 
 LOCAL_PATH := $(call my-dir)
+LLVM_ROOT_PATH := external/llvm
 
 mesa_SRC_FILES :=	\
     egl.cpp \
@@ -29,6 +30,7 @@ LOCAL_C_INCLUDES :=	\
 	$(LOCAL_PATH)   \
 	frameworks/compile/mesa/include
 
+include $(LLVM_ROOT_PATH)/llvm-host-build.mk
 include $(BUILD_HOST_EXECUTABLE)
 
 # Executable for target
@@ -51,6 +53,7 @@ LOCAL_C_INCLUDES :=	\
 	$(LOCAL_PATH)	\
 	frameworks/compile/mesa/include
 
+include $(LLVM_ROOT_PATH)/llvm-device-build.mk
 include $(BUILD_EXECUTABLE)
 
 endif # TARGET_SIMULATOR != true
diff --git a/test/cmain.c b/test/cmain.c
index 6271f2e..3ffeaa0 100644
--- a/test/cmain.c
+++ b/test/cmain.c
@@ -37,7 +37,7 @@ int cmain(int argc, char **argv)
       "   gl_Position = aPosition; \n"
       "   vTexCoord = aTexCoord + uVec4; \n"
       "   vTexColor = texture2D(sampler2d, aTexCoord.zw); \n"
-      "   gl_PointSize = 432.0; \n"
+      "   gl_PointSize = 432; \n"
       "}";
    puts(glsl0);
    GLboolean compileStatus = ggl->ShaderCompile(ggl, shader0, glsl0, &infoLog);
@@ -69,7 +69,7 @@ int cmain(int argc, char **argv)
    ggl->ShaderAttributeBind(program0, 2, "aTexCoord");
    ggl->ShaderAttributeBind(program0, 3, "aPosition");
 
-   GLboolean linkStatus = ggl->ShaderProgramLink(ggl, program0, &infoLog);
+   GLboolean linkStatus = ggl->ShaderProgramLink(program0, &infoLog);
    if (!linkStatus)
       fprintf(stderr, "failed to link program 0, infoLog: \n %s \n", infoLog);
    assert(linkStatus);
@@ -79,7 +79,7 @@ int cmain(int argc, char **argv)
    unsigned texels0 [] = {0xffffffff, 0x22222222, 0x66666666, 0xffffffff};
    GGLTexture_t texture0 = {GL_TEXTURE_2D, GGL_PIXEL_FORMAT_RGBA_8888,
                             2, 2, 1, // width, height, levelCount
-                            texels0, 1, 2, 1, 1
+                            texels0, GGL_CLAMP_TO_EDGE, GGL_MIRRORED_REPEAT, GGL_LINEAR, GGL_LINEAR
                            }; // levels, wrapS, wrapT, minFilter, magFilter
 
    int sampler2dLoc = ggl->ShaderUniformLocation(program0, "sampler2d");
@@ -122,8 +122,18 @@ int cmain(int argc, char **argv)
       assert(0);
    }
 
-// TODO DXL linear filtering needs to be fixed for texcoord outside of [0,1]
-   v0.attributes[2] = VECTOR4_CTR(0,0, 0.5f, 0.5f);
+   v0.attributes[2] = VECTOR4_CTR(0,0, 1.5f, 1.5f);
+   texture0.wrapS = GGL_REPEAT;
+   texture0.wrapT = GGL_REPEAT;
+
+   sampler2dLoc = ggl->ShaderUniformLocation(program0, "sampler2d");
+   if (0 <= sampler2dLoc) {
+      int samplerUnit = -1;
+      //ggl->ShaderUniformGetiv(ggl, program0, sampler2dLoc, &samplerUnit);
+      samplerUnit = sampler2dLoc;
+      ggl->SetSampler(ggl, samplerUnit, &texture0);
+   }
+   ggl->ShaderUse(ggl, program0);
    ggl->ProcessVertex(ggl, &v0, &vout0);
    const float filtered = (float)(0xff + 0x22 + 0x66 + 0xff) / (4 * 0xff);
    if (!ApproximatelyEqual(vout0.varyings[vTexColorIndex],
@@ -149,7 +159,7 @@ int cmain(int argc, char **argv)
    ggl->ClearColor(ggl, 0.1f, 0.1f, 0.1f, 1.0f);
    ggl->ClearDepthf(ggl, 0.5f);
 
-// TODO DXL scanline and fs test
+// TODO DXL test scanline and fs
 
    free(colorSurface.data);
    colorSurface.data = NULL;
diff --git a/test/egl.cpp b/test/egl.cpp
index 5b55400..f31e30d 100644
--- a/test/egl.cpp
+++ b/test/egl.cpp
@@ -693,12 +693,6 @@ EGLBoolean egl_window_surface_v2_t::bindDrawSurface(ogles_context_t* gl)
    //puts("egl_window_surface_v2_t::bindDrawSurface");
    //printf("\t width=%d height=%d stride=%d format=%d \n", buffer.width, buffer.height, buffer.stride, buffer.format);
 
-   /*for (unsigned int y = 0; y < buffer.height; y++)
-   {
-      unsigned int * line = (unsigned int *)bits + y * buffer.stride;
-      for (unsigned int x = 0; x < buffer.width; x++)
-         line[x] = 0xff00ff00;
-   }*/
    gl->width = this->buffer->width;
    gl->height = this->buffer->height;
    gl->stride = this->buffer->stride;
@@ -1926,15 +1920,7 @@ static struct S
    sp<Surface> surface;
    ~S()
    {
-      //surface->dispose();
-      surface.~sp();
-      puts("surface.~sp()");
-      //surfaceControl->dispose();
-      surfaceControl.~sp();
-      puts("surfaceControl.~sp()");
       client->dispose();
-      client.~sp();
-      puts("client.~sp()");
    }
 } * s = NULL;
 static ANativeWindow * window;
@@ -2014,15 +2000,10 @@ extern "C" void * PresentDrawingSurface()
 
 extern "C" void DisposeDrawingSurface()
 {
-   puts("DisposeDrawingSurface");
    eglDestroySurface(display, drawSurface);
-   puts("eglDestroySurface");
    eglDestroyContext(display, eglCtx);
-   puts("eglDestroyContext");
    delete s;
-   puts("delete s");
    s = NULL;
-   
    puts("DisposeDrawingSurface");
 }
 
diff --git a/test/main.cpp b/test/main.cpp
index d51c6d9..5bcb1ca 100644
--- a/test/main.cpp
+++ b/test/main.cpp
@@ -78,7 +78,7 @@ gl_shader_program * init_shader()
    ggl->ShaderAttach(ggl, program, vertShader);
    ggl->ShaderAttach(ggl, program, fragShader);
    const char * infoLog = NULL;
-   GLboolean linkStatus = ggl->ShaderProgramLink(ggl, program, &infoLog);
+   GLboolean linkStatus = ggl->ShaderProgramLink(program, &infoLog);
 
    printf("finished linking, LinkStatus=%d \n %s \n", linkStatus, infoLog);
 
@@ -108,7 +108,7 @@ void test_scan()
    frameSurface.format = GGL_PIXEL_FORMAT_RGBA_8888;
    frameSurface.width = width;
    frameSurface.height = height;
-   
+
    GGLSurface depthSurface = {0};
    depthSurface.width = width;
    depthSurface.height = height;
@@ -145,8 +145,8 @@ void test_scan()
 #endif
    texture.type = GL_TEXTURE_2D;
    texture.levelCount = 1;
-   texture.wrapS = texture.wrapT = 0; // repeat = 0 fastest, clamp = 1, mirrored = 2
-   texture.minFilter = texture.magFilter = 0; // nearest = 0, linear = 1
+   texture.wrapS = texture.wrapT = GGLTexture::GGL_REPEAT; // repeat = 0 fastest, clamp = 1, mirrored = 2
+   texture.minFilter = texture.magFilter = GGLTexture::GGL_NEAREST; // nearest = 0, linear = 1
    //texture.levelCount = GenerateMipmaps(texture.levels, texture.width, texture.height);
 
    //    static unsigned texels [6] = {0xff0000ff, 0xff00ff00, 0xffff0000,
@@ -171,7 +171,7 @@ void test_scan()
 
    ggl->SetBuffer(ggl, GL_COLOR_BUFFER_BIT, &frameSurface);
 
-   
+
    ggl->EnableDisable(ggl, GL_DEPTH_TEST, true);
    ggl->DepthFunc(ggl, GL_LESS);
 
@@ -195,7 +195,7 @@ void test_scan()
    int uRotMLoc = ggl->ShaderUniformLocation(program, "uRotM");
    int uTLoc = ggl->ShaderUniformLocation(program, "t");
 
-   GGLTexture cubeTexture = {GL_TEXTURE_CUBE_MAP, GGL_PIXEL_FORMAT_RGBA_8888, 1, 1, 1, NULL, 1, 2, 1, 1};
+   GGLTexture cubeTexture = {GL_TEXTURE_CUBE_MAP, GGL_PIXEL_FORMAT_RGBA_8888, 1, 1, 1, NULL, GGLTexture::GGL_CLAMP_TO_EDGE, GGLTexture::GGL_MIRRORED_REPEAT, GGLTexture::GGL_LINEAR, GGLTexture::GGL_LINEAR};
    unsigned cubeTextureSurface [6] = {0xff0000ff, 0xff00ff00, 0xffff0000,
                                       0xff00ffff, 0xffffff00, 0xffff00ff
                                      };
@@ -264,8 +264,8 @@ void test_scan()
    ggl->EnableDisable(ggl, GL_BLEND, false);
    ggl->EnableDisable(ggl, GL_DEPTH_TEST, true);
    ggl->EnableDisable(ggl, GL_STENCIL_TEST, false);
-   
-   
+
+
    ggl->DrawTriangle(ggl, &v0, &v0, &v0); // cause re-JIT to not mess up timing
 
    puts("\n -- begin rendering -- \n");
@@ -278,7 +278,7 @@ void test_scan()
 #endif
    for (
 #ifdef __arm__
-      unsigned i = 0; i <= 360; i++
+      unsigned i = 0; i <= 90; i++
 #else
       unsigned i = 0; i <= 10; i+= 1
 #endif
@@ -326,7 +326,7 @@ void test_scan()
       //ggl->BlendColor(ggl,(float)i / 10, (float) i / 15, (float)i < 20, 1);
 
       for (unsigned j = 0; j < sizeof(indices) / sizeof(*indices); j += 3)
-          ggl->DrawTriangle(ggl, vertices + indices[j], vertices + indices[j+1], vertices + indices[j+2]);
+         ggl->DrawTriangle(ggl, vertices + indices[j], vertices + indices[j+1], vertices + indices[j+2]);
 
       // including clear, depth, and other ops, direct ScanLine calls are 4% faster than DrawTriangle
       // X86 memcpy is 0.60ms vs 4.90ms for 480*800 fs texturing
@@ -429,7 +429,7 @@ void test_scan()
 
    ggl->SetBuffer(ggl, GL_COLOR_BUFFER_BIT, NULL);
 #if defined __arm__ && DRAW_TO_SCREEN
-   //DisposeDrawingSurface();
+   DisposeDrawingSurface();
 #else
    free(frameSurface.data);
 #endif
@@ -451,10 +451,150 @@ void test_scan()
 
 extern "C" int cmain(int,char**);
 
+#include "llvm/LLVMContext.h"
+
+void GLContextDctr();
+
+void contextless_test()
+{
+   static const char vsGLSL [] =
+      "uniform vec4 uVec4; \n"
+      "uniform sampler2D sampler2d; \n"
+      "attribute vec4 aPosition; \n"
+      "attribute vec4 aTexCoord; \n"
+      "varying vec4 vTexCoord; \n"
+      "varying vec4 vTexColor; \n"
+      "void main() { \n"
+      "   gl_Position = aPosition; \n"
+      "   vTexCoord = aTexCoord; \n"
+      "   vTexColor = texture2D(sampler2d, aTexCoord.zw); \n"
+      "   gl_PointSize = 432.0; \n"
+      "}";
+   gl_shader * vs = GGLShaderCreate(GL_VERTEX_SHADER);
+   const char * infoLog = NULL;
+   if (!GGLShaderCompile(vs, vsGLSL, &infoLog)) {
+      printf("GGLShaderCompile vs failed:\n%s\n", infoLog);
+      assert(0);
+   }
+   static const char fsGLSL [] =
+      "uniform vec4 uVec4; \n"
+      "uniform sampler2D sampler2d; \n"
+      "varying vec4 vTexCoord; \n"
+      "varying vec4 vTexColor; \n"
+      "void main() { \n"
+      "   gl_FragColor = texture2D(sampler2d, vTexCoord.zw); \n"
+      "}";
+   gl_shader * fs = GGLShaderCreate(GL_FRAGMENT_SHADER);
+   if (!GGLShaderCompile(fs, fsGLSL, &infoLog)) {
+      printf("GGLShaderCompile fs failed:\n%s\n", infoLog);
+      assert(0);
+   }
+   gl_shader_program * prog = GGLShaderProgramCreate();
+   unsigned glError = GL_NO_ERROR;
+   glError = GGLShaderAttach(prog, vs);
+   assert(GL_NO_ERROR == glError);
+   glError = GGLShaderAttach(prog, fs);
+   assert(GL_NO_ERROR == glError);
+   GGLShaderAttributeBind(prog, 4, "aPosition");
+   GGLShaderAttributeBind(prog, 5, "aTexCoord");
+   if (!GGLShaderProgramLink(prog, &infoLog)) {
+      printf("GGLShaderProgramLink failed:\n%s\n", infoLog);
+      assert(0);
+   }
+   llvm::LLVMContext * llvmCtx = new llvm::LLVMContext();
+   GGLState gglState = {0};
+   unsigned texels0 [] = {0xff10ffff, 0x22222222, 0x66666666, 0xffffffff};
+   GGLTexture_t texture0 = {GL_TEXTURE_2D, GGL_PIXEL_FORMAT_RGBA_8888,
+                            2, 2, 1, // width, height, levelCount
+                            texels0, GGLTexture::GGL_CLAMP_TO_EDGE, GGLTexture::GGL_CLAMP_TO_EDGE,
+                            GGLTexture::GGL_NEAREST, GGLTexture::GGL_NEAREST
+                           };
+   gglState.textureState.textures[0] = texture0;
+   gglState.textureState.textureData[0] = gglState.textureState.textures[0].levels;
+   gglState.textureState.textureDimensions[0 * 2 + 0] = gglState.textureState.textures[0].width;
+   gglState.textureState.textureDimensions[0 * 2 + 1] = gglState.textureState.textures[0].height;
+   GGLShaderUse(llvmCtx, &gglState, prog);
+
+   VertexInput input = {0, 0, 0, 0, Vector4(0,0,0,1), Vector4(0,0,0,0)};
+   VertexOutput output = {0};
+   GGLProcessVertex(prog, &input, &output, NULL);
+   int vTexColor = -1;
+   GGLShaderVaryingLocation(prog, "vTexColor", &vTexColor);
+   if (vTexColor >= 0) {
+      if (((Vector4 *)&output)[vTexColor] != Vector4(1,1,16/255.0f,1)) {
+         puts("((Vector4 *)&output)[vTexColor] != Vector4(1,1,0,1)");
+         assert(0);
+      }
+   } else {
+      puts("vTexColor < 0");
+      assert(0);
+   }
+
+   static const char fsGLSL1 [] =
+      "uniform vec4 uVec4; \n"
+      "uniform sampler2D sampler2d; \n"
+      "varying vec4 vTexCoord; \n"
+      "varying vec4 vTexColor; \n"
+      "void main() { \n"
+      "   gl_FragColor = vTexColor; \n"
+      "}";
+   gl_shader * fs1 = GGLShaderCreate(GL_FRAGMENT_SHADER);
+   if (!GGLShaderCompile(fs1, fsGLSL1, &infoLog)) {
+      printf("GGLShaderCompile fs failed:\n%s\n", infoLog);
+      assert(0);
+   }
+   gl_shader_program * prog1 = GGLShaderProgramCreate();
+   glError = GGLShaderAttach(prog1, vs);
+   assert(GL_NO_ERROR == glError);
+   glError = GGLShaderAttach(prog1, fs1);
+   assert(GL_NO_ERROR == glError);
+   GGLShaderAttributeBind(prog1, 1, "aPosition");
+   GGLShaderAttributeBind(prog1, 2, "aTexCoord");
+   if (!GGLShaderProgramLink(prog1, &infoLog)) {
+      printf("GGLShaderProgramLink failed:\n%s\n", infoLog);
+      assert(0);
+   }
+
+   GGLShaderUse(llvmCtx, &gglState, prog1);
+   VertexInput input1 = {0, Vector4(1,1,0,1), Vector4(1,1,0,0)};
+   VertexOutput output1 = {0};
+   GGLProcessVertex(prog1, &input1, &output1, NULL);
+   int vTexCoord = -1;
+   assert(2 == GGLShaderAttributeLocation(prog1, "aTexCoord"));
+   GGLShaderVaryingLocation(prog1, "vTexCoord", &vTexCoord);
+   if (vTexCoord >= 0) {
+      if (((Vector4 *)&output1)[vTexCoord] != input1.attributes[2]) {
+         puts("((Vector4 *)&output1)[vTexCoord] != input1.attributes[1]");
+         assert(0);
+      }
+   } else {
+      puts("vTexCoord < 0");
+      assert(0);
+   }
+
+   puts("***\n finished contextless_test \n***");
+
+   GGLShaderProgramDelete(prog);
+   GGLShaderProgramDelete(prog1);
+   
+   GLContextDctr();
+}
+
+extern "C" void hieralloc_report(const void *, FILE *);
+extern "C" void hieralloc_report_brief(const void *, FILE *);
+
 int main (int argc, char * const argv[])
 {
    cmain(0,NULL);
+
+   contextless_test();
+   
+//   contextless_test();
+   
    test_scan();
+   
+//   hieralloc_report(NULL, stdout);
+   hieralloc_report_brief(NULL, stdout);
    puts("mesa done");
    return 0;
 }
diff --git a/test/mesa.project b/test/mesa.project
index f88f153..d0ecf6b 100644
--- a/test/mesa.project
+++ b/test/mesa.project
@@ -15,12 +15,17 @@
     <File Name="m_matrix.c"/>
     <File Name="m_matrix.h"/>
   </VirtualDirectory>
+  <Dependencies Name="Release"/>
+  <Dependencies Name="Debug">
+    <Project Name="libMesa"/>
+  </Dependencies>
   <Settings Type="Executable">
     <Configuration Name="Debug" CompilerType="gnu gcc" DebuggerType="GNU gdb debugger" Type="Executable" BuildCmpWithGlobalSettings="append" BuildLnkWithGlobalSettings="append" BuildResWithGlobalSettings="append">
-      <Compiler Options="-g;-D__STDC_LIMIT_MACROS;-D__STDC_CONSTANT_MACROS;-m32 -march=i686;-DDEBUG;-UNDEBUG;-O0" Required="yes" PreCompiledHeader="">
+      <Compiler Options="-D__STDC_LIMIT_MACROS;-D__STDC_CONSTANT_MACROS;-m32 -march=i686;-DDEBUG;-UNDEBUG;-O0;-g" Required="yes" PreCompiledHeader="">
         <IncludePath Value="."/>
         <IncludePath Value="../include/"/>
         <IncludePath Value="../../../base/opengl/include"/>
+        <IncludePath Value="../../../../external/llvm/include"/>
       </Compiler>
       <Linker Options="-m32 -lstdc++ -ldl -lpthread -lbcc" Required="yes">
         <LibraryPath Value="../Debug"/>
@@ -87,7 +92,4 @@
       <ResourceCompiler Options=""/>
     </GlobalSettings>
   </Settings>
-  <Dependencies Name="Debug">
-    <Project Name="libMesa"/>
-  </Dependencies>
 </CodeLite_Project>