src/mesa/program/program.c - platform/external/mesa3d - Git at Google

 /*
  * Mesa 3-D graphics library
  *
  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
  * to deal in the Software without restriction, including without limitation
  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  * and/or sell copies of the Software, and to permit persons to whom the
  * Software is furnished to do so, subject to the following conditions:
  *
  * The above copyright notice and this permission notice shall be included
  * in all copies or substantial portions of the Software.
  *
  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  * OTHER DEALINGS IN THE SOFTWARE.
  */

 /**
  * \file program.c
  * Vertex and fragment program support functions.
  * \author Brian Paul
  */


 #include "main/glheader.h"
 #include "main/context.h"
 #include "main/framebuffer.h"
 #include "main/hash.h"
 #include "main/macros.h"
 #include "main/shaderobj.h"
 #include "program.h"
 #include "prog_cache.h"
 #include "prog_parameter.h"
 #include "prog_instruction.h"
 #include "util/ralloc.h"


 /**
  * A pointer to this dummy program is put into the hash table when
  * glGenPrograms is called.
  */
 struct gl_program _mesa_DummyProgram;


 /**
  * Init context's vertex/fragment program state
  */
 void
 _mesa_init_program(struct gl_context *ctx)
 {
    /*
     * If this assertion fails, we need to increase the field
     * size for register indexes (see INST_INDEX_BITS).
     */
    assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents / 4
           <= (1 << INST_INDEX_BITS));
    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents / 4
           <= (1 << INST_INDEX_BITS));

    assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxTemps <= (1 << INST_INDEX_BITS));
    assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxLocalParams <= (1 << INST_INDEX_BITS));
    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTemps <= (1 << INST_INDEX_BITS));
    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams <= (1 << INST_INDEX_BITS));

    assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents <= 4 * MAX_UNIFORMS);
    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents <= 4 * MAX_UNIFORMS);

    assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxAddressOffset <= (1 << INST_INDEX_BITS));
    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxAddressOffset <= (1 << INST_INDEX_BITS));

    /* If this fails, increase prog_instruction::TexSrcUnit size */
    STATIC_ASSERT(MAX_TEXTURE_UNITS <= (1 << 5));

    /* If this fails, increase prog_instruction::TexSrcTarget size */
    STATIC_ASSERT(NUM_TEXTURE_TARGETS <= (1 << 4));

    ctx->Program.ErrorPos = -1;
    ctx->Program.ErrorString = strdup("");

    ctx->VertexProgram.Enabled = GL_FALSE;
    ctx->VertexProgram.PointSizeEnabled =
       (ctx->API == API_OPENGLES2) ? GL_TRUE : GL_FALSE;
    ctx->VertexProgram.TwoSideEnabled = GL_FALSE;
    _mesa_reference_program(ctx, &ctx->VertexProgram.Current,
                            ctx->Shared->DefaultVertexProgram);
    assert(ctx->VertexProgram.Current);
    ctx->VertexProgram.Cache = _mesa_new_program_cache();

    ctx->FragmentProgram.Enabled = GL_FALSE;
    _mesa_reference_program(ctx, &ctx->FragmentProgram.Current,
                            ctx->Shared->DefaultFragmentProgram);
    assert(ctx->FragmentProgram.Current);
    ctx->FragmentProgram.Cache = _mesa_new_program_cache();

    /* XXX probably move this stuff */
    ctx->ATIFragmentShader.Enabled = GL_FALSE;
    ctx->ATIFragmentShader.Current = ctx->Shared->DefaultFragmentShader;
    assert(ctx->ATIFragmentShader.Current);
    ctx->ATIFragmentShader.Current->RefCount++;
 }


 /**
  * Free a context's vertex/fragment program state
  */
 void
 _mesa_free_program_data(struct gl_context *ctx)
 {
    _mesa_reference_program(ctx, &ctx->VertexProgram.Current, NULL);
    _mesa_delete_program_cache(ctx, ctx->VertexProgram.Cache);
    _mesa_reference_program(ctx, &ctx->FragmentProgram.Current, NULL);
    _mesa_delete_shader_cache(ctx, ctx->FragmentProgram.Cache);

    /* XXX probably move this stuff */
    if (ctx->ATIFragmentShader.Current) {
       ctx->ATIFragmentShader.Current->RefCount--;
       if (ctx->ATIFragmentShader.Current->RefCount <= 0) {
          free(ctx->ATIFragmentShader.Current);
       }
    }

    free((void *) ctx->Program.ErrorString);
 }


 /**
  * Update the default program objects in the given context to reference those
  * specified in the shared state and release those referencing the old
  * shared state.
  */
 void
 _mesa_update_default_objects_program(struct gl_context *ctx)
 {
    _mesa_reference_program(ctx, &ctx->VertexProgram.Current,
                            ctx->Shared->DefaultVertexProgram);
    assert(ctx->VertexProgram.Current);

    _mesa_reference_program(ctx, &ctx->FragmentProgram.Current,
                             ctx->Shared->DefaultFragmentProgram);
    assert(ctx->FragmentProgram.Current);

    /* XXX probably move this stuff */
    if (ctx->ATIFragmentShader.Current) {
       ctx->ATIFragmentShader.Current->RefCount--;
       if (ctx->ATIFragmentShader.Current->RefCount <= 0) {
          free(ctx->ATIFragmentShader.Current);
       }
    }
    ctx->ATIFragmentShader.Current = (struct ati_fragment_shader *) ctx->Shared->DefaultFragmentShader;
    assert(ctx->ATIFragmentShader.Current);
    ctx->ATIFragmentShader.Current->RefCount++;
 }


 /**
  * Set the vertex/fragment program error state (position and error string).
  * This is generally called from within the parsers.
  */
 void
 _mesa_set_program_error(struct gl_context *ctx, GLint pos, const char *string)
 {
    ctx->Program.ErrorPos = pos;
    free((void *) ctx->Program.ErrorString);
    if (!string)
       string = "";
    ctx->Program.ErrorString = strdup(string);
 }


 /**
  * Initialize a new gl_program object.
  */
 struct gl_program *
 _mesa_init_gl_program(struct gl_program *prog, GLenum target, GLuint id,
                       bool is_arb_asm)
 {
    if (!prog)
       return NULL;

    memset(prog, 0, sizeof(*prog));
    mtx_init(&prog->Mutex, mtx_plain);
    prog->Id = id;
    prog->Target = target;
    prog->RefCount = 1;
    prog->Format = GL_PROGRAM_FORMAT_ASCII_ARB;
    prog->info.stage = _mesa_program_enum_to_shader_stage(target);
    prog->is_arb_asm = is_arb_asm;

    /* Uniforms that lack an initializer in the shader code have an initial
     * value of zero.  This includes sampler uniforms.
     *
     * Page 24 (page 30 of the PDF) of the GLSL 1.20 spec says:
     *
     *     "The link time initial value is either the value of the variable's
     *     initializer, if present, or 0 if no initializer is present. Sampler
     *     types cannot have initializers."
     *
     * So we only initialise ARB assembly style programs.
     */
    if (is_arb_asm) {
       /* default mapping from samplers to texture units */
       for (unsigned i = 0; i < MAX_SAMPLERS; i++)
          prog->SamplerUnits[i] = i;
    }

    return prog;
 }


 /**
  * Allocate and initialize a new fragment/vertex program object but
  * don't put it into the program hash table.  Called via
  * ctx->Driver.NewProgram.  May be overridden (ie. replaced) by a
  * device driver function to implement OO deriviation with additional
  * types not understood by this function.
  *
  * \param ctx  context
  * \param id   program id/number
  * \param target  program target/type
  * \return  pointer to new program object
  */
 struct gl_program *
 _mesa_new_program(struct gl_context *ctx, GLenum target, GLuint id,
                   bool is_arb_asm)
 {
    switch (target) {
    case GL_VERTEX_PROGRAM_ARB: /* == GL_VERTEX_PROGRAM_NV */
    case GL_GEOMETRY_PROGRAM_NV:
    case GL_TESS_CONTROL_PROGRAM_NV:
    case GL_TESS_EVALUATION_PROGRAM_NV:
    case GL_FRAGMENT_PROGRAM_ARB:
    case GL_COMPUTE_PROGRAM_NV: {
       struct gl_program *prog = rzalloc(NULL, struct gl_program);
       return _mesa_init_gl_program(prog, target, id, is_arb_asm);
    }
    default:
       _mesa_problem(ctx, "bad target in _mesa_new_program");
       return NULL;
    }
 }


 /**
  * Delete a program and remove it from the hash table, ignoring the
  * reference count.
  * Called via ctx->Driver.DeleteProgram.  May be wrapped (OO deriviation)
  * by a device driver function.
  */
 void
 _mesa_delete_program(struct gl_context *ctx, struct gl_program *prog)
 {
    (void) ctx;
    assert(prog);
    assert(prog->RefCount==0);

    if (prog == &_mesa_DummyProgram)
       return;

    if (prog->Parameters) {
       _mesa_free_parameter_list(prog->Parameters);
    }

    if (prog->nir) {
       ralloc_free(prog->nir);
    }

    mtx_destroy(&prog->Mutex);
    ralloc_free(prog);
 }


 /**
  * Return the gl_program object for a given ID.
  * Basically just a wrapper for _mesa_HashLookup() to avoid a lot of
  * casts elsewhere.
  */
 struct gl_program *
 _mesa_lookup_program(struct gl_context *ctx, GLuint id)
 {
    if (id)
       return (struct gl_program *) _mesa_HashLookup(ctx->Shared->Programs, id);
    else
       return NULL;
 }


 /**
  * Reference counting for vertex/fragment programs
  * This is normally only called from the _mesa_reference_program() macro
  * when there's a real pointer change.
  */
 void
 _mesa_reference_program_(struct gl_context *ctx,
                          struct gl_program **ptr,
                          struct gl_program *prog)
 {
 #ifndef NDEBUG
    assert(ptr);
    if (*ptr && prog) {
       /* sanity check */
       if ((*ptr)->Target == GL_VERTEX_PROGRAM_ARB)
          assert(prog->Target == GL_VERTEX_PROGRAM_ARB);
       else if ((*ptr)->Target == GL_FRAGMENT_PROGRAM_ARB)
          assert(prog->Target == GL_FRAGMENT_PROGRAM_ARB ||
                 prog->Target == GL_FRAGMENT_PROGRAM_NV);
       else if ((*ptr)->Target == GL_GEOMETRY_PROGRAM_NV)
          assert(prog->Target == GL_GEOMETRY_PROGRAM_NV);
    }
 #endif

    if (*ptr) {
       GLboolean deleteFlag;
       struct gl_program *oldProg = *ptr;

       mtx_lock(&oldProg->Mutex);
       assert(oldProg->RefCount > 0);
       oldProg->RefCount--;

       deleteFlag = (oldProg->RefCount == 0);
       mtx_unlock(&oldProg->Mutex);

       if (deleteFlag) {
          assert(ctx);
          _mesa_reference_shader_program_data(ctx, &oldProg->sh.data, NULL);
          ctx->Driver.DeleteProgram(ctx, oldProg);
       }

       *ptr = NULL;
    }

    assert(!*ptr);
    if (prog) {
       mtx_lock(&prog->Mutex);
       prog->RefCount++;
       mtx_unlock(&prog->Mutex);
    }

    *ptr = prog;
 }


 /**
  * Insert 'count' NOP instructions at 'start' in the given program.
  * Adjust branch targets accordingly.
  */
 GLboolean
 _mesa_insert_instructions(struct gl_program *prog, GLuint start, GLuint count)
 {
    const GLuint origLen = prog->arb.NumInstructions;
    const GLuint newLen = origLen + count;
    struct prog_instruction *newInst;
    GLuint i;

    /* adjust branches */
    for (i = 0; i < prog->arb.NumInstructions; i++) {
       struct prog_instruction *inst = prog->arb.Instructions + i;
       if (inst->BranchTarget > 0) {
          if ((GLuint)inst->BranchTarget >= start) {
             inst->BranchTarget += count;
          }
       }
    }

    /* Alloc storage for new instructions */
    newInst = rzalloc_array(prog, struct prog_instruction, newLen);
    if (!newInst) {
       return GL_FALSE;
    }

    /* Copy 'start' instructions into new instruction buffer */
    _mesa_copy_instructions(newInst, prog->arb.Instructions, start);

    /* init the new instructions */
    _mesa_init_instructions(newInst + start, count);

    /* Copy the remaining/tail instructions to new inst buffer */
    _mesa_copy_instructions(newInst + start + count,
                            prog->arb.Instructions + start,
                            origLen - start);

    /* free old instructions */
    ralloc_free(prog->arb.Instructions);

    /* install new instructions */
    prog->arb.Instructions = newInst;
    prog->arb.NumInstructions = newLen;

    return GL_TRUE;
 }

 /**
  * Delete 'count' instructions at 'start' in the given program.
  * Adjust branch targets accordingly.
  */
 GLboolean
 _mesa_delete_instructions(struct gl_program *prog, GLuint start, GLuint count,
                           void *mem_ctx)
 {
    const GLuint origLen = prog->arb.NumInstructions;
    const GLuint newLen = origLen - count;
    struct prog_instruction *newInst;
    GLuint i;

    /* adjust branches */
    for (i = 0; i < prog->arb.NumInstructions; i++) {
       struct prog_instruction *inst = prog->arb.Instructions + i;
       if (inst->BranchTarget > 0) {
          if (inst->BranchTarget > (GLint) start) {
             inst->BranchTarget -= count;
          }
       }
    }

    /* Alloc storage for new instructions */
    newInst = rzalloc_array(mem_ctx, struct prog_instruction, newLen);
    if (!newInst) {
       return GL_FALSE;
    }

    /* Copy 'start' instructions into new instruction buffer */
    _mesa_copy_instructions(newInst, prog->arb.Instructions, start);

    /* Copy the remaining/tail instructions to new inst buffer */
    _mesa_copy_instructions(newInst + start,
                            prog->arb.Instructions + start + count,
                            newLen - start);

    /* free old instructions */
    ralloc_free(prog->arb.Instructions);

    /* install new instructions */
    prog->arb.Instructions = newInst;
    prog->arb.NumInstructions = newLen;

    return GL_TRUE;
 }


 /**
  * Populate the 'used' array with flags indicating which registers (TEMPs,
  * INPUTs, OUTPUTs, etc, are used by the given program.
  * \param file  type of register to scan for
  * \param used  returns true/false flags for in use / free
  * \param usedSize  size of the 'used' array
  */
 void
 _mesa_find_used_registers(const struct gl_program *prog,
                           gl_register_file file,
                           GLboolean used[], GLuint usedSize)
 {
    GLuint i, j;

    memset(used, 0, usedSize);

    for (i = 0; i < prog->arb.NumInstructions; i++) {
       const struct prog_instruction *inst = prog->arb.Instructions + i;
       const GLuint n = _mesa_num_inst_src_regs(inst->Opcode);

       if (inst->DstReg.File == file) {
          assert(inst->DstReg.Index < usedSize);
          if(inst->DstReg.Index < usedSize)
             used[inst->DstReg.Index] = GL_TRUE;
       }

       for (j = 0; j < n; j++) {
          if (inst->SrcReg[j].File == file) {
             assert(inst->SrcReg[j].Index < (GLint) usedSize);
             if (inst->SrcReg[j].Index < (GLint) usedSize)
                used[inst->SrcReg[j].Index] = GL_TRUE;
          }
       }
    }
 }


 /**
  * Scan the given 'used' register flag array for the first entry
  * that's >= firstReg.
  * \param used  vector of flags indicating registers in use (as returned
  *              by _mesa_find_used_registers())
  * \param usedSize  size of the 'used' array
  * \param firstReg  first register to start searching at
  * \return index of unused register, or -1 if none.
  */
 GLint
 _mesa_find_free_register(const GLboolean used[],
                          GLuint usedSize, GLuint firstReg)
 {
    GLuint i;

    assert(firstReg < usedSize);

    for (i = firstReg; i < usedSize; i++)
       if (!used[i])
          return i;

    return -1;
 }


 /* Gets the minimum number of shader invocations per fragment.
  * This function is useful to determine if we need to do per
  * sample shading or per fragment shading.
  */
 GLint
 _mesa_get_min_invocations_per_fragment(struct gl_context *ctx,
                                        const struct gl_program *prog,
                                        bool ignore_sample_qualifier)
 {
    /* From ARB_sample_shading specification:
     * "Using gl_SampleID in a fragment shader causes the entire shader
     *  to be evaluated per-sample."
     *
     * "Using gl_SamplePosition in a fragment shader causes the entire
     *  shader to be evaluated per-sample."
     *
     * "If MULTISAMPLE or SAMPLE_SHADING_ARB is disabled, sample shading
     *  has no effect."
     */
    if (ctx->Multisample.Enabled) {
       /* The ARB_gpu_shader5 specification says:
        *
        * "Use of the "sample" qualifier on a fragment shader input
        *  forces per-sample shading"
        */
       if (prog->info.fs.uses_sample_qualifier && !ignore_sample_qualifier)
          return MAX2(_mesa_geometric_samples(ctx->DrawBuffer), 1);

       if (prog->info.system_values_read & (SYSTEM_BIT_SAMPLE_ID |
                                            SYSTEM_BIT_SAMPLE_POS))
          return MAX2(_mesa_geometric_samples(ctx->DrawBuffer), 1);
       else if (ctx->Multisample.SampleShading)
          return MAX2(ceil(ctx->Multisample.MinSampleShadingValue *
                           _mesa_geometric_samples(ctx->DrawBuffer)), 1);
       else
          return 1;
    }
    return 1;
 }
	/*
	* Mesa 3-D graphics library
	*
	* Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
	*
	* Permission is hereby granted, free of charge, to any person obtaining a
	* copy of this software and associated documentation files (the "Software"),
	* to deal in the Software without restriction, including without limitation
	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	* and/or sell copies of the Software, and to permit persons to whom the
	* Software is furnished to do so, subject to the following conditions:
	*
	* The above copyright notice and this permission notice shall be included
	* in all copies or substantial portions of the Software.
	*
	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
	* OTHER DEALINGS IN THE SOFTWARE.
	*/

	/**
	* \file program.c
	* Vertex and fragment program support functions.
	* \author Brian Paul
	*/


	#include "main/glheader.h"
	#include "main/context.h"
	#include "main/framebuffer.h"
	#include "main/hash.h"
	#include "main/macros.h"
	#include "main/shaderobj.h"
	#include "program.h"
	#include "prog_cache.h"
	#include "prog_parameter.h"
	#include "prog_instruction.h"
	#include "util/ralloc.h"


	/**
	* A pointer to this dummy program is put into the hash table when
	* glGenPrograms is called.
	*/
	struct gl_program _mesa_DummyProgram;


	/**
	* Init context's vertex/fragment program state
	*/
	void
	_mesa_init_program(struct gl_context *ctx)
	{
	/*
	* If this assertion fails, we need to increase the field
	* size for register indexes (see INST_INDEX_BITS).
	*/
	assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents / 4
	<= (1 << INST_INDEX_BITS));
	assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents / 4
	<= (1 << INST_INDEX_BITS));

	assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxTemps <= (1 << INST_INDEX_BITS));
	assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxLocalParams <= (1 << INST_INDEX_BITS));
	assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTemps <= (1 << INST_INDEX_BITS));
	assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams <= (1 << INST_INDEX_BITS));

	assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents <= 4 * MAX_UNIFORMS);
	assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents <= 4 * MAX_UNIFORMS);

	assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxAddressOffset <= (1 << INST_INDEX_BITS));
	assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxAddressOffset <= (1 << INST_INDEX_BITS));

	/* If this fails, increase prog_instruction::TexSrcUnit size */
	STATIC_ASSERT(MAX_TEXTURE_UNITS <= (1 << 5));

	/* If this fails, increase prog_instruction::TexSrcTarget size */
	STATIC_ASSERT(NUM_TEXTURE_TARGETS <= (1 << 4));

	ctx->Program.ErrorPos = -1;
	ctx->Program.ErrorString = strdup("");

	ctx->VertexProgram.Enabled = GL_FALSE;
	ctx->VertexProgram.PointSizeEnabled =
	(ctx->API == API_OPENGLES2) ? GL_TRUE : GL_FALSE;
	ctx->VertexProgram.TwoSideEnabled = GL_FALSE;
	_mesa_reference_program(ctx, &ctx->VertexProgram.Current,
	ctx->Shared->DefaultVertexProgram);
	assert(ctx->VertexProgram.Current);
	ctx->VertexProgram.Cache = _mesa_new_program_cache();

	ctx->FragmentProgram.Enabled = GL_FALSE;
	_mesa_reference_program(ctx, &ctx->FragmentProgram.Current,
	ctx->Shared->DefaultFragmentProgram);
	assert(ctx->FragmentProgram.Current);
	ctx->FragmentProgram.Cache = _mesa_new_program_cache();

	/* XXX probably move this stuff */
	ctx->ATIFragmentShader.Enabled = GL_FALSE;
	ctx->ATIFragmentShader.Current = ctx->Shared->DefaultFragmentShader;
	assert(ctx->ATIFragmentShader.Current);
	ctx->ATIFragmentShader.Current->RefCount++;
	}


	/**
	* Free a context's vertex/fragment program state
	*/
	void
	_mesa_free_program_data(struct gl_context *ctx)
	{
	_mesa_reference_program(ctx, &ctx->VertexProgram.Current, NULL);
	_mesa_delete_program_cache(ctx, ctx->VertexProgram.Cache);
	_mesa_reference_program(ctx, &ctx->FragmentProgram.Current, NULL);
	_mesa_delete_shader_cache(ctx, ctx->FragmentProgram.Cache);

	/* XXX probably move this stuff */
	if (ctx->ATIFragmentShader.Current) {
	ctx->ATIFragmentShader.Current->RefCount--;
	if (ctx->ATIFragmentShader.Current->RefCount <= 0) {
	free(ctx->ATIFragmentShader.Current);
	}
	}

	free((void *) ctx->Program.ErrorString);
	}


	/**
	* Update the default program objects in the given context to reference those
	* specified in the shared state and release those referencing the old
	* shared state.
	*/
	void
	_mesa_update_default_objects_program(struct gl_context *ctx)
	{
	_mesa_reference_program(ctx, &ctx->VertexProgram.Current,
	ctx->Shared->DefaultVertexProgram);
	assert(ctx->VertexProgram.Current);

	_mesa_reference_program(ctx, &ctx->FragmentProgram.Current,
	ctx->Shared->DefaultFragmentProgram);
	assert(ctx->FragmentProgram.Current);

	/* XXX probably move this stuff */
	if (ctx->ATIFragmentShader.Current) {
	ctx->ATIFragmentShader.Current->RefCount--;
	if (ctx->ATIFragmentShader.Current->RefCount <= 0) {
	free(ctx->ATIFragmentShader.Current);
	}
	}
	ctx->ATIFragmentShader.Current = (struct ati_fragment_shader *) ctx->Shared->DefaultFragmentShader;
	assert(ctx->ATIFragmentShader.Current);
	ctx->ATIFragmentShader.Current->RefCount++;
	}


	/**
	* Set the vertex/fragment program error state (position and error string).
	* This is generally called from within the parsers.
	*/
	void
	_mesa_set_program_error(struct gl_context ctx, GLint pos, const char string)
	{
	ctx->Program.ErrorPos = pos;
	free((void *) ctx->Program.ErrorString);
	if (!string)
	string = "";
	ctx->Program.ErrorString = strdup(string);
	}


	/**
	* Initialize a new gl_program object.
	*/
	struct gl_program *
	_mesa_init_gl_program(struct gl_program *prog, GLenum target, GLuint id,
	bool is_arb_asm)
	{
	if (!prog)
	return NULL;

	memset(prog, 0, sizeof(*prog));
	mtx_init(&prog->Mutex, mtx_plain);
	prog->Id = id;
	prog->Target = target;
	prog->RefCount = 1;
	prog->Format = GL_PROGRAM_FORMAT_ASCII_ARB;
	prog->info.stage = _mesa_program_enum_to_shader_stage(target);
	prog->is_arb_asm = is_arb_asm;

	/* Uniforms that lack an initializer in the shader code have an initial
	* value of zero. This includes sampler uniforms.
	*
	* Page 24 (page 30 of the PDF) of the GLSL 1.20 spec says:
	*
	* "The link time initial value is either the value of the variable's
	* initializer, if present, or 0 if no initializer is present. Sampler
	* types cannot have initializers."
	*
	* So we only initialise ARB assembly style programs.
	*/
	if (is_arb_asm) {
	/* default mapping from samplers to texture units */
	for (unsigned i = 0; i < MAX_SAMPLERS; i++)
	prog->SamplerUnits[i] = i;
	}

	return prog;
	}


	/**
	* Allocate and initialize a new fragment/vertex program object but
	* don't put it into the program hash table. Called via
	* ctx->Driver.NewProgram. May be overridden (ie. replaced) by a
	* device driver function to implement OO deriviation with additional
	* types not understood by this function.
	*
	* \param ctx context
	* \param id program id/number
	* \param target program target/type
	* \return pointer to new program object
	*/
	struct gl_program *
	_mesa_new_program(struct gl_context *ctx, GLenum target, GLuint id,
	bool is_arb_asm)
	{
	switch (target) {
	case GL_VERTEX_PROGRAM_ARB: /* == GL_VERTEX_PROGRAM_NV */
	case GL_GEOMETRY_PROGRAM_NV:
	case GL_TESS_CONTROL_PROGRAM_NV:
	case GL_TESS_EVALUATION_PROGRAM_NV:
	case GL_FRAGMENT_PROGRAM_ARB:
	case GL_COMPUTE_PROGRAM_NV: {
	struct gl_program *prog = rzalloc(NULL, struct gl_program);
	return _mesa_init_gl_program(prog, target, id, is_arb_asm);
	}
	default:
	_mesa_problem(ctx, "bad target in _mesa_new_program");
	return NULL;
	}
	}


	/**
	* Delete a program and remove it from the hash table, ignoring the
	* reference count.
	* Called via ctx->Driver.DeleteProgram. May be wrapped (OO deriviation)
	* by a device driver function.
	*/
	void
	_mesa_delete_program(struct gl_context ctx, struct gl_program prog)
	{
	(void) ctx;
	assert(prog);
	assert(prog->RefCount==0);

	if (prog == &_mesa_DummyProgram)
	return;

	if (prog->Parameters) {
	_mesa_free_parameter_list(prog->Parameters);
	}

	if (prog->nir) {
	ralloc_free(prog->nir);
	}

	mtx_destroy(&prog->Mutex);
	ralloc_free(prog);
	}


	/**
	* Return the gl_program object for a given ID.
	* Basically just a wrapper for _mesa_HashLookup() to avoid a lot of
	* casts elsewhere.
	*/
	struct gl_program *
	_mesa_lookup_program(struct gl_context *ctx, GLuint id)
	{
	if (id)
	return (struct gl_program *) _mesa_HashLookup(ctx->Shared->Programs, id);
	else
	return NULL;
	}


	/**
	* Reference counting for vertex/fragment programs
	* This is normally only called from the _mesa_reference_program() macro
	* when there's a real pointer change.
	*/
	void
	_mesa_reference_program_(struct gl_context *ctx,
	struct gl_program **ptr,
	struct gl_program *prog)
	{
	#ifndef NDEBUG
	assert(ptr);
	if (*ptr && prog) {
	/* sanity check */
	if ((*ptr)->Target == GL_VERTEX_PROGRAM_ARB)
	assert(prog->Target == GL_VERTEX_PROGRAM_ARB);
	else if ((*ptr)->Target == GL_FRAGMENT_PROGRAM_ARB)
	assert(prog->Target == GL_FRAGMENT_PROGRAM_ARB \|\|
	prog->Target == GL_FRAGMENT_PROGRAM_NV);
	else if ((*ptr)->Target == GL_GEOMETRY_PROGRAM_NV)
	assert(prog->Target == GL_GEOMETRY_PROGRAM_NV);
	}
	#endif

	if (*ptr) {
	GLboolean deleteFlag;
	struct gl_program oldProg = ptr;

	mtx_lock(&oldProg->Mutex);
	assert(oldProg->RefCount > 0);
	oldProg->RefCount--;

	deleteFlag = (oldProg->RefCount == 0);
	mtx_unlock(&oldProg->Mutex);

	if (deleteFlag) {
	assert(ctx);
	_mesa_reference_shader_program_data(ctx, &oldProg->sh.data, NULL);
	ctx->Driver.DeleteProgram(ctx, oldProg);
	}

	*ptr = NULL;
	}

	assert(!*ptr);
	if (prog) {
	mtx_lock(&prog->Mutex);
	prog->RefCount++;
	mtx_unlock(&prog->Mutex);
	}

	*ptr = prog;
	}


	/**
	* Insert 'count' NOP instructions at 'start' in the given program.
	* Adjust branch targets accordingly.
	*/
	GLboolean
	_mesa_insert_instructions(struct gl_program *prog, GLuint start, GLuint count)
	{
	const GLuint origLen = prog->arb.NumInstructions;
	const GLuint newLen = origLen + count;
	struct prog_instruction *newInst;
	GLuint i;

	/* adjust branches */
	for (i = 0; i < prog->arb.NumInstructions; i++) {
	struct prog_instruction *inst = prog->arb.Instructions + i;
	if (inst->BranchTarget > 0) {
	if ((GLuint)inst->BranchTarget >= start) {
	inst->BranchTarget += count;
	}
	}
	}

	/* Alloc storage for new instructions */
	newInst = rzalloc_array(prog, struct prog_instruction, newLen);
	if (!newInst) {
	return GL_FALSE;
	}

	/* Copy 'start' instructions into new instruction buffer */
	_mesa_copy_instructions(newInst, prog->arb.Instructions, start);

	/* init the new instructions */
	_mesa_init_instructions(newInst + start, count);

	/* Copy the remaining/tail instructions to new inst buffer */
	_mesa_copy_instructions(newInst + start + count,
	prog->arb.Instructions + start,
	origLen - start);

	/* free old instructions */
	ralloc_free(prog->arb.Instructions);

	/* install new instructions */
	prog->arb.Instructions = newInst;
	prog->arb.NumInstructions = newLen;

	return GL_TRUE;
	}

	/**
	* Delete 'count' instructions at 'start' in the given program.
	* Adjust branch targets accordingly.
	*/
	GLboolean
	_mesa_delete_instructions(struct gl_program *prog, GLuint start, GLuint count,
	void *mem_ctx)
	{
	const GLuint origLen = prog->arb.NumInstructions;
	const GLuint newLen = origLen - count;
	struct prog_instruction *newInst;
	GLuint i;

	/* adjust branches */
	for (i = 0; i < prog->arb.NumInstructions; i++) {
	struct prog_instruction *inst = prog->arb.Instructions + i;
	if (inst->BranchTarget > 0) {
	if (inst->BranchTarget > (GLint) start) {
	inst->BranchTarget -= count;
	}
	}
	}

	/* Alloc storage for new instructions */
	newInst = rzalloc_array(mem_ctx, struct prog_instruction, newLen);
	if (!newInst) {
	return GL_FALSE;
	}

	/* Copy 'start' instructions into new instruction buffer */
	_mesa_copy_instructions(newInst, prog->arb.Instructions, start);

	/* Copy the remaining/tail instructions to new inst buffer */
	_mesa_copy_instructions(newInst + start,
	prog->arb.Instructions + start + count,
	newLen - start);

	/* free old instructions */
	ralloc_free(prog->arb.Instructions);

	/* install new instructions */
	prog->arb.Instructions = newInst;
	prog->arb.NumInstructions = newLen;

	return GL_TRUE;
	}


	/**
	* Populate the 'used' array with flags indicating which registers (TEMPs,
	* INPUTs, OUTPUTs, etc, are used by the given program.
	* \param file type of register to scan for
	* \param used returns true/false flags for in use / free
	* \param usedSize size of the 'used' array
	*/
	void
	_mesa_find_used_registers(const struct gl_program *prog,
	gl_register_file file,
	GLboolean used[], GLuint usedSize)
	{
	GLuint i, j;

	memset(used, 0, usedSize);

	for (i = 0; i < prog->arb.NumInstructions; i++) {
	const struct prog_instruction *inst = prog->arb.Instructions + i;
	const GLuint n = _mesa_num_inst_src_regs(inst->Opcode);

	if (inst->DstReg.File == file) {
	assert(inst->DstReg.Index < usedSize);
	if(inst->DstReg.Index < usedSize)
	used[inst->DstReg.Index] = GL_TRUE;
	}

	for (j = 0; j < n; j++) {
	if (inst->SrcReg[j].File == file) {
	assert(inst->SrcReg[j].Index < (GLint) usedSize);
	if (inst->SrcReg[j].Index < (GLint) usedSize)
	used[inst->SrcReg[j].Index] = GL_TRUE;
	}
	}
	}
	}


	/**
	* Scan the given 'used' register flag array for the first entry
	* that's >= firstReg.
	* \param used vector of flags indicating registers in use (as returned
	* by _mesa_find_used_registers())
	* \param usedSize size of the 'used' array
	* \param firstReg first register to start searching at
	* \return index of unused register, or -1 if none.
	*/
	GLint
	_mesa_find_free_register(const GLboolean used[],
	GLuint usedSize, GLuint firstReg)
	{
	GLuint i;

	assert(firstReg < usedSize);

	for (i = firstReg; i < usedSize; i++)
	if (!used[i])
	return i;

	return -1;
	}


	/* Gets the minimum number of shader invocations per fragment.
	* This function is useful to determine if we need to do per
	* sample shading or per fragment shading.
	*/
	GLint
	_mesa_get_min_invocations_per_fragment(struct gl_context *ctx,
	const struct gl_program *prog,
	bool ignore_sample_qualifier)
	{
	/* From ARB_sample_shading specification:
	* "Using gl_SampleID in a fragment shader causes the entire shader
	* to be evaluated per-sample."
	*
	* "Using gl_SamplePosition in a fragment shader causes the entire
	* shader to be evaluated per-sample."
	*
	* "If MULTISAMPLE or SAMPLE_SHADING_ARB is disabled, sample shading
	* has no effect."
	*/
	if (ctx->Multisample.Enabled) {
	/* The ARB_gpu_shader5 specification says:
	*
	* "Use of the "sample" qualifier on a fragment shader input
	* forces per-sample shading"
	*/
	if (prog->info.fs.uses_sample_qualifier && !ignore_sample_qualifier)
	return MAX2(_mesa_geometric_samples(ctx->DrawBuffer), 1);

	if (prog->info.system_values_read & (SYSTEM_BIT_SAMPLE_ID \|
	SYSTEM_BIT_SAMPLE_POS))
	return MAX2(_mesa_geometric_samples(ctx->DrawBuffer), 1);
	else if (ctx->Multisample.SampleShading)
	return MAX2(ceil(ctx->Multisample.MinSampleShadingValue *
	_mesa_geometric_samples(ctx->DrawBuffer)), 1);
	else
	return 1;
	}
	return 1;
	}