void r3xx_compile_vertex_program(struct r300_vertex_program_compiler* compiler)
{
compiler->Base.SwizzleCaps = &r300_vertprog_swizzle_caps;
addArtificialOutputs(compiler);
{
struct radeon_program_transformation transformations[] = {
{ &r300_transform_vertex_alu, 0 },
};
radeonLocalTransform(&compiler->Base, 1, transformations);
}
if (compiler->Base.Debug) {
fprintf(stderr, "Vertex program after native rewrite:\n");
rc_print_program(&compiler->Base.Program);
fflush(stderr);
}
{
/* Note: This pass has to be done seperately from ALU rewrite,
* otherwise non-native ALU instructions with source conflits
* will not be treated properly.
*/
struct radeon_program_transformation transformations[] = {
{ &transform_source_conflicts, 0 },
};
radeonLocalTransform(&compiler->Base, 1, transformations);
}
if (compiler->Base.Debug) {
fprintf(stderr, "Vertex program after source conflict resolve:\n");
rc_print_program(&compiler->Base.Program);
fflush(stderr);
}
rc_dataflow_deadcode(&compiler->Base, &dataflow_outputs_mark_used, compiler);
if (compiler->Base.Debug) {
fprintf(stderr, "Vertex program after deadcode:\n");
rc_print_program(&compiler->Base.Program);
fflush(stderr);
}
rc_dataflow_swizzles(&compiler->Base);
allocate_temporary_registers(compiler);
if (compiler->Base.Debug) {
fprintf(stderr, "Vertex program after dataflow:\n");
rc_print_program(&compiler->Base.Program);
fflush(stderr);
}
translate_vertex_program(compiler);
rc_constants_copy(&compiler->code->constants, &compiler->Base.Program.Constants);
compiler->code->InputsRead = compiler->Base.Program.InputsRead;
compiler->code->OutputsWritten = compiler->Base.Program.OutputsWritten;
if (compiler->Base.Debug) {
fprintf(stderr, "Final vertex program code:\n");
r300_vertex_program_dump(compiler->code);
}
}
void r300TranslateFragmentShader(r300ContextPtr r300,
struct r300_fragment_program *fp)
{
struct r300_fragment_program_external_state state;
build_state(r300, fp, &state);
if (_mesa_memcmp(&fp->state, &state, sizeof(state))) {
/* TODO: cache compiled programs */
fp->translated = GL_FALSE;
_mesa_memcpy(&fp->state, &state, sizeof(state));
}
if (!fp->translated) {
struct r300_fragment_program_compiler compiler;
compiler.r300 = r300;
compiler.fp = fp;
compiler.code = &fp->code;
compiler.program = _mesa_clone_program(r300->radeon.glCtx, &fp->mesa_program.Base);
if (RADEON_DEBUG & DEBUG_PIXEL) {
_mesa_printf("Fragment Program: Initial program:\n");
_mesa_print_program(compiler.program);
}
insert_WPOS_trailer(&compiler);
struct radeon_program_transformation transformations[] = {
{ &transform_TEX, &compiler },
{ &radeonTransformALU, 0 },
{ &radeonTransformTrigSimple, 0 }
};
radeonLocalTransform(
r300->radeon.glCtx,
compiler.program,
3, transformations);
if (RADEON_DEBUG & DEBUG_PIXEL) {
_mesa_printf("Fragment Program: After native rewrite:\n");
_mesa_print_program(compiler.program);
}
struct radeon_nqssadce_descr nqssadce = {
.Init = &nqssadce_init,
.IsNativeSwizzle = &r300FPIsNativeSwizzle,
.BuildSwizzle = &r300FPBuildSwizzle,
.RewriteDepthOut = GL_TRUE
};
radeonNqssaDce(r300->radeon.glCtx, compiler.program, &nqssadce);
if (RADEON_DEBUG & DEBUG_PIXEL) {
_mesa_printf("Compiler: after NqSSA-DCE:\n");
_mesa_print_program(compiler.program);
}
if (!r300FragmentProgramEmit(&compiler))
fp->error = GL_TRUE;
/* Subtle: Rescue any parameters that have been added during transformations */
_mesa_free_parameter_list(fp->mesa_program.Base.Parameters);
fp->mesa_program.Base.Parameters = compiler.program->Parameters;
compiler.program->Parameters = 0;
_mesa_reference_program(r300->radeon.glCtx, &compiler.program, NULL);
if (!fp->error)
fp->translated = GL_TRUE;
if (fp->error || (RADEON_DEBUG & DEBUG_PIXEL))
r300FragmentProgramDump(fp, &fp->code);
r300UpdateStateParameters(r300->radeon.glCtx, _NEW_PROGRAM);
}
update_params(r300, fp);
}
void r3xx_compile_fragment_program(struct r300_fragment_program_compiler* c)
{
rewrite_depth_out(c);
if (c->is_r500) {
struct radeon_program_transformation transformations[] = {
{ &r500_transform_TEX, c },
{ &r500_transform_IF, 0 },
{ &radeonTransformALU, 0 },
{ &radeonTransformDeriv, 0 },
{ &radeonTransformTrigScale, 0 }
};
radeonLocalTransform(&c->Base, 5, transformations);
c->Base.SwizzleCaps = &r500_swizzle_caps;
} else {
struct radeon_program_transformation transformations[] = {
{ &r300_transform_TEX, c },
{ &radeonTransformALU, 0 },
{ &radeonTransformTrigSimple, 0 }
};
radeonLocalTransform(&c->Base, 3, transformations);
c->Base.SwizzleCaps = &r300_swizzle_caps;
}
if (c->Base.Debug) {
fprintf(stderr, "Fragment Program: After native rewrite:\n");
rc_print_program(&c->Base.Program);
fflush(stderr);
}
rc_dataflow_deadcode(&c->Base, &dataflow_outputs_mark_use, c);
if (c->Base.Error)
return;
if (c->Base.Debug) {
fprintf(stderr, "Fragment Program: After deadcode:\n");
rc_print_program(&c->Base.Program);
fflush(stderr);
}
rc_dataflow_swizzles(&c->Base);
if (c->Base.Error)
return;
if (c->Base.Debug) {
fprintf(stderr, "Compiler: after dataflow passes:\n");
rc_print_program(&c->Base.Program);
fflush(stderr);
}
rc_pair_translate(c);
if (c->Base.Error)
return;
if (c->Base.Debug) {
fprintf(stderr, "Compiler: after pair translate:\n");
rc_print_program(&c->Base.Program);
fflush(stderr);
}
rc_pair_schedule(c);
if (c->Base.Error)
return;
if (c->Base.Debug) {
fprintf(stderr, "Compiler: after pair scheduling:\n");
rc_print_program(&c->Base.Program);
fflush(stderr);
}
if (c->is_r500)
rc_pair_regalloc(c, 128);
else
rc_pair_regalloc(c, R300_PFS_NUM_TEMP_REGS);
if (c->Base.Error)
return;
if (c->Base.Debug) {
fprintf(stderr, "Compiler: after pair register allocation:\n");
rc_print_program(&c->Base.Program);
fflush(stderr);
}
if (c->is_r500) {
r500BuildFragmentProgramHwCode(c);
} else {
r300BuildFragmentProgramHwCode(c);
}
rc_constants_copy(&c->code->constants, &c->Base.Program.Constants);
if (c->Base.Debug) {
if (c->is_r500) {
r500FragmentProgramDump(c->code);
} else {
r300FragmentProgramDump(c->code);
}
}
}
