static void rc_print_normal_instruction(FILE * f, struct rc_instruction * inst, unsigned *branch_depth)
{
	const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->U.I.Opcode);
	unsigned int reg;
	unsigned spaces = update_branch_depth(inst->U.I.Opcode, branch_depth);

	for (unsigned i = 0; i < spaces; i++)
		fprintf(f, " ");

	fprintf(f, "%s", opcode->Name);

	switch(inst->U.I.SaturateMode) {
	case RC_SATURATE_NONE: break;
	case RC_SATURATE_ZERO_ONE: fprintf(f, "_SAT"); break;
	case RC_SATURATE_MINUS_PLUS_ONE: fprintf(f, "_SAT2"); break;
	default: fprintf(f, "_BAD_SAT"); break;
	}

	if (opcode->HasDstReg) {
		fprintf(f, " ");
		rc_print_dst_register(f, inst->U.I.DstReg);
		print_omod_op(f, inst->U.I.Omod);
		if (opcode->NumSrcRegs)
			fprintf(f, ",");
	}

	for(reg = 0; reg < opcode->NumSrcRegs; ++reg) {
		if (reg > 0)
			fprintf(f, ",");
		fprintf(f, " ");
		rc_print_src_register(f, inst, inst->U.I.SrcReg[reg]);
	}

	if (opcode->HasTexture) {
		fprintf(f, ", %s%s[%u]%s%s",
			textarget_to_string(inst->U.I.TexSrcTarget),
			inst->U.I.TexShadow ? "SHADOW" : "",
			inst->U.I.TexSrcUnit,
			inst->U.I.TexSemWait ? " SEM_WAIT" : "",
			inst->U.I.TexSemAcquire ? " SEM_ACQUIRE" : "");
	}

	fprintf(f, ";");

	if (inst->U.I.WriteALUResult) {
		fprintf(f, " [aluresult = (");
		rc_print_comparefunc(f,
			(inst->U.I.WriteALUResult == RC_ALURESULT_X) ? "x" : "w",
			inst->U.I.ALUResultCompare, "0");
		fprintf(f, ")]");
	}

	if (inst->U.I.DstReg.Pred == RC_PRED_SET) {
		fprintf(f, " PRED_SET");
	} else if (inst->U.I.DstReg.Pred == RC_PRED_INV) {
		fprintf(f, " PRED_INV");
	}

	fprintf(f, "\n");
}
Example #2
0
static void rc_print_pair_instruction(FILE * f, struct rc_instruction * fullinst, unsigned *branch_depth)
{
    struct rc_pair_instruction * inst = &fullinst->U.P;
    int printedsrc = 0;
    unsigned spaces = update_branch_depth(inst->RGB.Opcode != RC_OPCODE_NOP ?
                                          inst->RGB.Opcode : inst->Alpha.Opcode, branch_depth);

    for (unsigned i = 0; i < spaces; i++)
        fprintf(f, " ");

    for(unsigned int src = 0; src < 3; ++src) {
        if (inst->RGB.Src[src].Used) {
            if (printedsrc)
                fprintf(f, ", ");
            fprintf(f, "src%i.xyz = ", src);
            rc_print_register(f, inst->RGB.Src[src].File, inst->RGB.Src[src].Index, 0);
            printedsrc = 1;
        }
        if (inst->Alpha.Src[src].Used) {
            if (printedsrc)
                fprintf(f, ", ");
            fprintf(f, "src%i.w = ", src);
            rc_print_register(f, inst->Alpha.Src[src].File, inst->Alpha.Src[src].Index, 0);
            printedsrc = 1;
        }
    }
    if(inst->RGB.Src[RC_PAIR_PRESUB_SRC].Used) {
        fprintf(f, ", srcp.xyz = %s",
                presubtract_op_to_string(
                    inst->RGB.Src[RC_PAIR_PRESUB_SRC].Index));
    }
    if(inst->Alpha.Src[RC_PAIR_PRESUB_SRC].Used) {
        fprintf(f, ", srcp.w = %s",
                presubtract_op_to_string(
                    inst->Alpha.Src[RC_PAIR_PRESUB_SRC].Index));
    }
    if (inst->SemWait) {
        fprintf(f, " SEM_WAIT");
    }
    fprintf(f, "\n");

    if (inst->RGB.Opcode != RC_OPCODE_NOP) {
        const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->RGB.Opcode);

        for (unsigned i = 0; i < spaces; i++)
            fprintf(f, " ");

        fprintf(f, "     %s%s", opcode->Name, inst->RGB.Saturate ? "_SAT" : "");
        if (inst->RGB.WriteMask)
            fprintf(f, " temp[%i].%s%s%s", inst->RGB.DestIndex,
                    (inst->RGB.WriteMask & 1) ? "x" : "",
                    (inst->RGB.WriteMask & 2) ? "y" : "",
                    (inst->RGB.WriteMask & 4) ? "z" : "");
        if (inst->RGB.OutputWriteMask)
            fprintf(f, " color[%i].%s%s%s", inst->RGB.Target,
                    (inst->RGB.OutputWriteMask & 1) ? "x" : "",
                    (inst->RGB.OutputWriteMask & 2) ? "y" : "",
                    (inst->RGB.OutputWriteMask & 4) ? "z" : "");
        if (inst->WriteALUResult == RC_ALURESULT_X)
            fprintf(f, " aluresult");

        print_omod_op(f, inst->RGB.Omod);

        for(unsigned int arg = 0; arg < opcode->NumSrcRegs; ++arg) {
            const char* abs = inst->RGB.Arg[arg].Abs ? "|" : "";
            const char* neg = inst->RGB.Arg[arg].Negate ? "-" : "";
            fprintf(f, ", %s%ssrc", neg, abs);
            if(inst->RGB.Arg[arg].Source == RC_PAIR_PRESUB_SRC)
                fprintf(f,"p");
            else
                fprintf(f,"%d", inst->RGB.Arg[arg].Source);
            fprintf(f,".%c%c%c%s",
                    rc_swizzle_char(GET_SWZ(inst->RGB.Arg[arg].Swizzle, 0)),
                    rc_swizzle_char(GET_SWZ(inst->RGB.Arg[arg].Swizzle, 1)),
                    rc_swizzle_char(GET_SWZ(inst->RGB.Arg[arg].Swizzle, 2)),
                    abs);
        }
        fprintf(f, "\n");
    }

    if (inst->Alpha.Opcode != RC_OPCODE_NOP) {
        const struct rc_opcode_info * opcode = rc_get_opcode_info(inst->Alpha.Opcode);

        for (unsigned i = 0; i < spaces; i++)
            fprintf(f, " ");

        fprintf(f, "     %s%s", opcode->Name, inst->Alpha.Saturate ? "_SAT" : "");
        if (inst->Alpha.WriteMask)
            fprintf(f, " temp[%i].w", inst->Alpha.DestIndex);
        if (inst->Alpha.OutputWriteMask)
            fprintf(f, " color[%i].w", inst->Alpha.Target);
        if (inst->Alpha.DepthWriteMask)
            fprintf(f, " depth.w");
        if (inst->WriteALUResult == RC_ALURESULT_W)
            fprintf(f, " aluresult");

        print_omod_op(f, inst->Alpha.Omod);

        for(unsigned int arg = 0; arg < opcode->NumSrcRegs; ++arg) {
            const char* abs = inst->Alpha.Arg[arg].Abs ? "|" : "";
            const char* neg = inst->Alpha.Arg[arg].Negate ? "-" : "";
            fprintf(f, ", %s%ssrc", neg, abs);
            if(inst->Alpha.Arg[arg].Source == RC_PAIR_PRESUB_SRC)
                fprintf(f,"p");
            else
                fprintf(f,"%d", inst->Alpha.Arg[arg].Source);
            fprintf(f,".%c%s",
                    rc_swizzle_char(GET_SWZ(inst->Alpha.Arg[arg].Swizzle, 0)), abs);
        }
        fprintf(f, "\n");
    }

    if (inst->WriteALUResult) {
        for (unsigned i = 0; i < spaces; i++)
            fprintf(f, " ");

        fprintf(f, "      [aluresult = (");
        rc_print_comparefunc(f, "result", inst->ALUResultCompare, "0");
        fprintf(f, ")]\n");
    }
}