Skip to content
Snippets Groups Projects
Commit 5042a3ee authored by Marek Olšák's avatar Marek Olšák
Browse files

program: remove unused cloning and combining functions


Reviewed-by: default avatarEmil Velikov <emil.velikov@collabora.com>
Reviewed-by: default avatarBrian Paul <brianp@vmware.com>
parent c947a3a4
No related branches found
No related tags found
No related merge requests found
......@@ -450,123 +450,6 @@ _mesa_reference_program_(struct gl_context *ctx,
}
/**
* Return a copy of a program.
* XXX Problem here if the program object is actually OO-derivation
* made by a device driver.
*/
struct gl_program *
_mesa_clone_program(struct gl_context *ctx, const struct gl_program *prog)
{
struct gl_program *clone;
clone = ctx->Driver.NewProgram(ctx, prog->Target, prog->Id);
if (!clone)
return NULL;
assert(clone->Target == prog->Target);
assert(clone->RefCount == 1);
clone->String = (GLubyte *) strdup((char *) prog->String);
clone->Format = prog->Format;
clone->Instructions = _mesa_alloc_instructions(prog->NumInstructions);
if (!clone->Instructions) {
_mesa_reference_program(ctx, &clone, NULL);
return NULL;
}
_mesa_copy_instructions(clone->Instructions, prog->Instructions,
prog->NumInstructions);
clone->InputsRead = prog->InputsRead;
clone->OutputsWritten = prog->OutputsWritten;
clone->SamplersUsed = prog->SamplersUsed;
clone->ShadowSamplers = prog->ShadowSamplers;
memcpy(clone->TexturesUsed, prog->TexturesUsed, sizeof(prog->TexturesUsed));
if (prog->Parameters)
clone->Parameters = _mesa_clone_parameter_list(prog->Parameters);
if (prog->LocalParams) {
clone->LocalParams = malloc(MAX_PROGRAM_LOCAL_PARAMS *
sizeof(float[4]));
if (!clone->LocalParams) {
_mesa_reference_program(ctx, &clone, NULL);
return NULL;
}
memcpy(clone->LocalParams, prog->LocalParams,
MAX_PROGRAM_LOCAL_PARAMS * sizeof(float[4]));
}
clone->IndirectRegisterFiles = prog->IndirectRegisterFiles;
clone->NumInstructions = prog->NumInstructions;
clone->NumTemporaries = prog->NumTemporaries;
clone->NumParameters = prog->NumParameters;
clone->NumAttributes = prog->NumAttributes;
clone->NumAddressRegs = prog->NumAddressRegs;
clone->NumNativeInstructions = prog->NumNativeInstructions;
clone->NumNativeTemporaries = prog->NumNativeTemporaries;
clone->NumNativeParameters = prog->NumNativeParameters;
clone->NumNativeAttributes = prog->NumNativeAttributes;
clone->NumNativeAddressRegs = prog->NumNativeAddressRegs;
clone->NumAluInstructions = prog->NumAluInstructions;
clone->NumTexInstructions = prog->NumTexInstructions;
clone->NumTexIndirections = prog->NumTexIndirections;
clone->NumNativeAluInstructions = prog->NumNativeAluInstructions;
clone->NumNativeTexInstructions = prog->NumNativeTexInstructions;
clone->NumNativeTexIndirections = prog->NumNativeTexIndirections;
switch (prog->Target) {
case GL_VERTEX_PROGRAM_ARB:
{
const struct gl_vertex_program *vp = gl_vertex_program_const(prog);
struct gl_vertex_program *vpc = gl_vertex_program(clone);
vpc->IsPositionInvariant = vp->IsPositionInvariant;
}
break;
case GL_FRAGMENT_PROGRAM_ARB:
{
const struct gl_fragment_program *fp = gl_fragment_program_const(prog);
struct gl_fragment_program *fpc = gl_fragment_program(clone);
fpc->UsesKill = fp->UsesKill;
fpc->UsesDFdy = fp->UsesDFdy;
fpc->OriginUpperLeft = fp->OriginUpperLeft;
fpc->PixelCenterInteger = fp->PixelCenterInteger;
}
break;
case GL_GEOMETRY_PROGRAM_NV:
{
const struct gl_geometry_program *gp = gl_geometry_program_const(prog);
struct gl_geometry_program *gpc = gl_geometry_program(clone);
gpc->VerticesOut = gp->VerticesOut;
gpc->InputType = gp->InputType;
gpc->Invocations = gp->Invocations;
gpc->OutputType = gp->OutputType;
gpc->UsesEndPrimitive = gp->UsesEndPrimitive;
gpc->UsesStreams = gp->UsesStreams;
}
break;
case GL_TESS_CONTROL_PROGRAM_NV:
{
const struct gl_tess_ctrl_program *tcp = gl_tess_ctrl_program_const(prog);
struct gl_tess_ctrl_program *tcpc = gl_tess_ctrl_program(clone);
tcpc->VerticesOut = tcp->VerticesOut;
}
break;
case GL_TESS_EVALUATION_PROGRAM_NV:
{
const struct gl_tess_eval_program *tep = gl_tess_eval_program_const(prog);
struct gl_tess_eval_program *tepc = gl_tess_eval_program(clone);
tepc->PrimitiveMode = tep->PrimitiveMode;
tepc->Spacing = tep->Spacing;
tepc->VertexOrder = tep->VertexOrder;
tepc->PointMode = tep->PointMode;
}
break;
default:
_mesa_problem(NULL, "Unexpected target in _mesa_clone_program");
}
return clone;
}
/**
* Insert 'count' NOP instructions at 'start' in the given program.
* Adjust branch targets accordingly.
......@@ -714,139 +597,6 @@ adjust_param_indexes(struct prog_instruction *inst, GLuint numInst,
}
/**
* Combine two programs into one. Fix instructions so the outputs of
* the first program go to the inputs of the second program.
*/
struct gl_program *
_mesa_combine_programs(struct gl_context *ctx,
const struct gl_program *progA,
const struct gl_program *progB)
{
struct prog_instruction *newInst;
struct gl_program *newProg;
const GLuint lenA = progA->NumInstructions - 1; /* omit END instr */
const GLuint lenB = progB->NumInstructions;
const GLuint numParamsA = _mesa_num_parameters(progA->Parameters);
const GLuint newLength = lenA + lenB;
GLboolean usedTemps[MAX_PROGRAM_TEMPS];
GLuint firstTemp = 0;
GLbitfield64 inputsB;
GLuint i;
assert(progA->Target == progB->Target);
newInst = _mesa_alloc_instructions(newLength);
if (!newInst)
return GL_FALSE;
_mesa_copy_instructions(newInst, progA->Instructions, lenA);
_mesa_copy_instructions(newInst + lenA, progB->Instructions, lenB);
/* adjust branch / instruction addresses for B's instructions */
for (i = 0; i < lenB; i++) {
newInst[lenA + i].BranchTarget += lenA;
}
newProg = ctx->Driver.NewProgram(ctx, progA->Target, 0);
newProg->Instructions = newInst;
newProg->NumInstructions = newLength;
/* find used temp regs (we may need new temps below) */
_mesa_find_used_registers(newProg, PROGRAM_TEMPORARY,
usedTemps, MAX_PROGRAM_TEMPS);
if (newProg->Target == GL_FRAGMENT_PROGRAM_ARB) {
const struct gl_fragment_program *fprogA, *fprogB;
struct gl_fragment_program *newFprog;
GLbitfield64 progB_inputsRead = progB->InputsRead;
GLint progB_colorFile, progB_colorIndex;
fprogA = gl_fragment_program_const(progA);
fprogB = gl_fragment_program_const(progB);
newFprog = gl_fragment_program(newProg);
newFprog->UsesKill = fprogA->UsesKill || fprogB->UsesKill;
newFprog->UsesDFdy = fprogA->UsesDFdy || fprogB->UsesDFdy;
/* We'll do a search and replace for instances
* of progB_colorFile/progB_colorIndex below...
*/
progB_colorFile = PROGRAM_INPUT;
progB_colorIndex = VARYING_SLOT_COL0;
/*
* The fragment program may get color from a state var rather than
* a fragment input (vertex output) if it's constant.
* See the texenvprogram.c code.
* So, search the program's parameter list now to see if the program
* gets color from a state var instead of a conventional fragment
* input register.
*/
for (i = 0; i < progB->Parameters->NumParameters; i++) {
struct gl_program_parameter *p = &progB->Parameters->Parameters[i];
if (p->Type == PROGRAM_STATE_VAR &&
p->StateIndexes[0] == STATE_INTERNAL &&
p->StateIndexes[1] == STATE_CURRENT_ATTRIB &&
(int) p->StateIndexes[2] == (int) VERT_ATTRIB_COLOR0) {
progB_inputsRead |= VARYING_BIT_COL0;
progB_colorFile = PROGRAM_STATE_VAR;
progB_colorIndex = i;
break;
}
}
/* Connect color outputs of fprogA to color inputs of fprogB, via a
* new temporary register.
*/
if ((progA->OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_COLOR)) &&
(progB_inputsRead & VARYING_BIT_COL0)) {
GLint tempReg = _mesa_find_free_register(usedTemps, MAX_PROGRAM_TEMPS,
firstTemp);
if (tempReg < 0) {
_mesa_problem(ctx, "No free temp regs found in "
"_mesa_combine_programs(), using 31");
tempReg = 31;
}
firstTemp = tempReg + 1;
/* replace writes to result.color[0] with tempReg */
replace_registers(newInst, lenA,
PROGRAM_OUTPUT, FRAG_RESULT_COLOR,
PROGRAM_TEMPORARY, tempReg);
/* replace reads from the input color with tempReg */
replace_registers(newInst + lenA, lenB,
progB_colorFile, progB_colorIndex, /* search for */
PROGRAM_TEMPORARY, tempReg /* replace with */ );
}
/* compute combined program's InputsRead */
inputsB = progB_inputsRead;
if (progA->OutputsWritten & BITFIELD64_BIT(FRAG_RESULT_COLOR)) {
inputsB &= ~(1 << VARYING_SLOT_COL0);
}
newProg->InputsRead = progA->InputsRead | inputsB;
newProg->OutputsWritten = progB->OutputsWritten;
newProg->SamplersUsed = progA->SamplersUsed | progB->SamplersUsed;
}
else {
/* vertex program */
assert(0); /* XXX todo */
}
/*
* Merge parameters (uniforms, constants, etc)
*/
newProg->Parameters = _mesa_combine_parameter_lists(progA->Parameters,
progB->Parameters);
adjust_param_indexes(newInst + lenA, lenB, numParamsA);
return newProg;
}
/**
* Populate the 'used' array with flags indicating which registers (TEMPs,
* INPUTs, OUTPUTs, etc, are used by the given program.
......
......@@ -171,56 +171,12 @@ _mesa_reference_tesseprog(struct gl_context *ctx,
(struct gl_program *) prog);
}
extern struct gl_program *
_mesa_clone_program(struct gl_context *ctx, const struct gl_program *prog);
static inline struct gl_vertex_program *
_mesa_clone_vertex_program(struct gl_context *ctx,
const struct gl_vertex_program *prog)
{
return (struct gl_vertex_program *) _mesa_clone_program(ctx, &prog->Base);
}
static inline struct gl_tess_ctrl_program *
_mesa_clone_tess_ctrl_program(struct gl_context *ctx,
const struct gl_tess_ctrl_program *prog)
{
return (struct gl_tess_ctrl_program *) _mesa_clone_program(ctx, &prog->Base);
}
static inline struct gl_tess_eval_program *
_mesa_clone_tess_eval_program(struct gl_context *ctx,
const struct gl_tess_eval_program *prog)
{
return (struct gl_tess_eval_program *) _mesa_clone_program(ctx, &prog->Base);
}
static inline struct gl_geometry_program *
_mesa_clone_geometry_program(struct gl_context *ctx,
const struct gl_geometry_program *prog)
{
return (struct gl_geometry_program *) _mesa_clone_program(ctx, &prog->Base);
}
static inline struct gl_fragment_program *
_mesa_clone_fragment_program(struct gl_context *ctx,
const struct gl_fragment_program *prog)
{
return (struct gl_fragment_program *) _mesa_clone_program(ctx, &prog->Base);
}
extern GLboolean
_mesa_insert_instructions(struct gl_program *prog, GLuint start, GLuint count);
extern GLboolean
_mesa_delete_instructions(struct gl_program *prog, GLuint start, GLuint count);
extern struct gl_program *
_mesa_combine_programs(struct gl_context *ctx,
const struct gl_program *progA,
const struct gl_program *progB);
extern void
_mesa_find_used_registers(const struct gl_program *prog,
gl_register_file file,
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment