/**

 * MojoShader; generate shader programs from bytecode of compiled

 *  Direct3D shaders.

 *

 * Please see the file LICENSE.txt in the source's root directory.

 *

 *  This file written by Ryan C. Gordon.

 */

#define __MOJOSHADER_INTERNAL__ 1

#include "mojoshader_profile.h"

#pragma GCC visibility push(hidden)

#if SUPPORT_PROFILE_ARB1

static inline const char *get_ARB1_register_string(Context *ctx,

                        const RegisterType regtype, const int regnum,

                        char *regnum_str, const size_t regnum_size)

{

    // turns out these are identical at the moment.

    return get_D3D_register_string(ctx,regtype,regnum,regnum_str,regnum_size);

} // get_ARB1_register_string

int allocate_scratch_register(Context *ctx)

{

    const int retval = ctx->scratch_registers++;

    if (retval >= ctx->max_scratch_registers)

        ctx->max_scratch_registers = retval + 1;

    return retval;

} // allocate_scratch_register

int allocate_branch_label(Context *ctx)

{

    return ctx->assigned_branch_labels++;

} // allocate_branch_label

const char *allocate_ARB1_scratch_reg_name(Context *ctx, char *buf,

                                           const size_t buflen)

{

    const int scratch = allocate_scratch_register(ctx);

    snprintf(buf, buflen, "scratch%d", scratch);

    return buf;

} // allocate_ARB1_scratch_reg_name

static inline const char *get_ARB1_branch_label_name(Context *ctx, const int id,

                                                char *buf, const size_t buflen)

{

    snprintf(buf, buflen, "branch_label%d", id);

    return buf;

} // get_ARB1_branch_label_name

const char *get_ARB1_varname_in_buf(Context *ctx, const RegisterType rt,

                                    const int regnum, char *buf,

                                    const size_t buflen)

{

    // turns out these are identical at the moment.

    return get_D3D_varname_in_buf(ctx, rt, regnum, buf, buflen);

} // get_ARB1_varname_in_buf

const char *get_ARB1_varname(Context *ctx, const RegisterType rt,

                             const int regnum)

{

    // turns out these are identical at the moment.

    return get_D3D_varname(ctx, rt, regnum);

} // get_ARB1_varname

static inline const char *get_ARB1_const_array_varname_in_buf(Context *ctx,

                                                const int base, const int size,

                                                char *buf, const size_t buflen)

{

    snprintf(buf, buflen, "c_array_%d_%d", base, size);

    return buf;

} // get_ARB1_const_array_varname_in_buf

const char *get_ARB1_const_array_varname(Context *ctx, int base, int size)

{

    char buf[64];

    get_ARB1_const_array_varname_in_buf(ctx, base, size, buf, sizeof (buf));

    return StrDup(ctx, buf);

} // get_ARB1_const_array_varname

const char *make_ARB1_srcarg_string_in_buf(Context *ctx,

                                           const SourceArgInfo *arg,

                                           char *buf, size_t buflen)

{

    // !!! FIXME: this can hit pathological cases where we look like this...

    //

    //    dp3 r1.xyz, t0_bx2, t0_bx2

    //    mad r1.xyz, t0_bias, 1-r1, t0_bx2

    //

    // ...which do a lot of duplicate work in arb1...

    //

    //    SUB scratch0, t0, { 0.5, 0.5, 0.5, 0.5 };

    //    MUL scratch0, scratch0, { 2.0, 2.0, 2.0, 2.0 };

    //    SUB scratch1, t0, { 0.5, 0.5, 0.5, 0.5 };

    //    MUL scratch1, scratch1, { 2.0, 2.0, 2.0, 2.0 };

    //    DP3 r1.xyz, scratch0, scratch1;

    //    SUB scratch0, t0, { 0.5, 0.5, 0.5, 0.5 };

    //    SUB scratch1, { 1.0, 1.0, 1.0, 1.0 }, r1;

    //    SUB scratch2, t0, { 0.5, 0.5, 0.5, 0.5 };

    //    MUL scratch2, scratch2, { 2.0, 2.0, 2.0, 2.0 };

    //    MAD r1.xyz, scratch0, scratch1, scratch2;

    //

    // ...notice that the dp3 calculates the same value into two scratch

    //  registers. This case is easier to handle; just see if multiple

    //  source args are identical, build it up once, and use the same

    //  scratch register for multiple arguments in that opcode.

    //  Even better still, only calculate things once across instructions,

    //  and be smart about letting it linger in a scratch register until we

    //  definitely don't need the calculation anymore. That's harder to

    //  write, though.

    char regnum_str[16] = { '\0' };

    // !!! FIXME: use get_ARB1_varname_in_buf() instead?

    const char *regtype_str = NULL;

    if (!arg->relative)

    {

        regtype_str = get_ARB1_register_string(ctx, arg->regtype,

                                               arg->regnum, regnum_str,

                                               sizeof (regnum_str));

    } // if

    const char *rel_lbracket = "";

    char rel_offset[32] = { '\0' };

    const char *rel_rbracket = "";

    char rel_swizzle[4] = { '\0' };

    const char *rel_regtype_str = "";

    if (arg->relative)

    {

        rel_regtype_str = get_ARB1_varname_in_buf(ctx, arg->relative_regtype,

                                                  arg->relative_regnum,

                                                  (char *) alloca(64), 64);

        rel_swizzle[0] = '.';

        rel_swizzle[1] = swizzle_channels[arg->relative_component];

        rel_swizzle[2] = '\0';

        if (!support_nv2(ctx))

        {

            // The address register in ARB1 only allows the '.x' component, so

            //  we need to load the component we need from a temp vector

            //  register into .x as needed.

            assert(arg->relative_regtype == REG_TYPE_ADDRESS);

            assert(arg->relative_regnum == 0);

            if (ctx->last_address_reg_component != arg->relative_component)

            {

                output_line(ctx, "ARL %s.x, addr%d.%c;", rel_regtype_str,

                            arg->relative_regnum,

                            swizzle_channels[arg->relative_component]);

                ctx->last_address_reg_component = arg->relative_component;

            } // if

            rel_swizzle[1] = 'x';

        } // if

        if (arg->regtype == REG_TYPE_INPUT)

            regtype_str = "vertex.attrib";

        else

        {

            assert(arg->regtype == REG_TYPE_CONST);

            const int arrayidx = arg->relative_array->index;

            const int arraysize = arg->relative_array->count;

            const int offset = arg->regnum - arrayidx;

            assert(offset >= 0);

            regtype_str = get_ARB1_const_array_varname_in_buf(ctx, arrayidx,

                                           arraysize, (char *) alloca(64), 64);

            if (offset != 0)

                snprintf(rel_offset, sizeof (rel_offset), " + %d", offset);

        } // else

        rel_lbracket = "[";

        rel_rbracket = "]";

    } // if

    // This is the source register with everything but swizzle and source mods.

    snprintf(buf, buflen, "%s%s%s%s%s%s%s", regtype_str, regnum_str,

             rel_lbracket, rel_regtype_str, rel_swizzle, rel_offset,

             rel_rbracket);

    // Some of the source mods need to generate instructions to a temp

    //  register, in which case we'll replace the register name.

    const SourceMod mod = arg->src_mod;

    const int inplace = ( (mod == SRCMOD_NONE) || (mod == SRCMOD_NEGATE) ||

                          ((mod == SRCMOD_ABS) && support_nv2(ctx)) );

    if (!inplace)

    {

        const size_t len = 64;

        char *stackbuf = (char *) alloca(len);

        regtype_str = allocate_ARB1_scratch_reg_name(ctx, stackbuf, len);

        regnum_str[0] = '\0'; // move value to scratch register.

        rel_lbracket = "";   // scratch register won't use array.

        rel_rbracket = "";

        rel_offset[0] = '\0';

        rel_swizzle[0] = '\0';

        rel_regtype_str = "";

    } // if

    const char *premod_str = "";

    const char *postmod_str = "";

    switch (mod)

    {

        case SRCMOD_NEGATE:

            premod_str = "-";

            break;

        case SRCMOD_BIASNEGATE:

            premod_str = "-";

            // fall through.

        case SRCMOD_BIAS:

            output_line(ctx, "SUB %s, %s, { 0.5, 0.5, 0.5, 0.5 };",

                        regtype_str, buf);

            break;

        case SRCMOD_SIGNNEGATE:

            premod_str = "-";

            // fall through.

        case SRCMOD_SIGN:

            output_line(ctx,

                "MAD %s, %s, { 2.0, 2.0, 2.0, 2.0 }, { -1.0, -1.0, -1.0, -1.0 };",

                regtype_str, buf);

            break;

        case SRCMOD_COMPLEMENT:

            output_line(ctx, "SUB %s, { 1.0, 1.0, 1.0, 1.0 }, %s;",

                        regtype_str, buf);

            break;

        case SRCMOD_X2NEGATE:

            premod_str = "-";

            // fall through.

        case SRCMOD_X2:

            output_line(ctx, "MUL %s, %s, { 2.0, 2.0, 2.0, 2.0 };",

                        regtype_str, buf);

            break;

        case SRCMOD_DZ:

            fail(ctx, "SRCMOD_DZ currently unsupported in arb1");

            postmod_str = "_dz";

            break;

        case SRCMOD_DW:

            fail(ctx, "SRCMOD_DW currently unsupported in arb1");

            postmod_str = "_dw";

            break;

        case SRCMOD_ABSNEGATE:

            premod_str = "-";

            // fall through.

        case SRCMOD_ABS:

            if (!support_nv2(ctx))  // GL_NV_vertex_program2_option adds this.

                output_line(ctx, "ABS %s, %s;", regtype_str, buf);

            else

            {

                premod_str = (mod == SRCMOD_ABSNEGATE) ? "-|" : "|";

                postmod_str = "|";

            } // else

            break;

        case SRCMOD_NOT:

            fail(ctx, "SRCMOD_NOT currently unsupported in arb1");

            premod_str = "!";

            break;

        case SRCMOD_NONE:

        case SRCMOD_TOTAL:

             break;  // stop compiler whining.

    } // switch

    char swizzle_str[6];

    size_t i = 0;

    if (support_nv4(ctx))  // vFace must be output as "vFace.x" in nv4.

    {

        if (arg->regtype == REG_TYPE_MISCTYPE)

        {

            if ( ((const MiscTypeType) arg->regnum) == MISCTYPE_TYPE_FACE )

            {

                swizzle_str[i++] = '.';

                swizzle_str[i++] = 'x';

            } // if

        } // if

    } // if

    const int scalar = isscalar(ctx, ctx->shader_type, arg->regtype, arg->regnum);

    if (!scalar && !no_swizzle(arg->swizzle))

    {

        swizzle_str[i++] = '.';

        // .xxxx is the same as .x, but .xx is illegal...scalar or full!

        if (replicate_swizzle(arg->swizzle))

            swizzle_str[i++] = swizzle_channels[arg->swizzle_x];

        else

        {

            swizzle_str[i++] = swizzle_channels[arg->swizzle_x];

            swizzle_str[i++] = swizzle_channels[arg->swizzle_y];

            swizzle_str[i++] = swizzle_channels[arg->swizzle_z];

            swizzle_str[i++] = swizzle_channels[arg->swizzle_w];

        } // else

    } // if

    swizzle_str[i] = '\0';

    assert(i < sizeof (swizzle_str));

    snprintf(buf, buflen, "%s%s%s%s%s%s%s%s%s%s", premod_str,

             regtype_str, regnum_str, rel_lbracket,

             rel_regtype_str, rel_swizzle, rel_offset, rel_rbracket,

             swizzle_str, postmod_str);

    // !!! FIXME: make sure the scratch buffer was large enough.

    return buf;

} // make_ARB1_srcarg_string_in_buf

const char *get_ARB1_destarg_varname(Context *ctx, char *buf,

                                     const size_t buflen)

{

    const DestArgInfo *arg = &ctx->dest_arg;

    return get_ARB1_varname_in_buf(ctx, arg->regtype, arg->regnum, buf, buflen);

} // get_ARB1_destarg_varname

const char *get_ARB1_srcarg_varname(Context *ctx, const size_t idx,

                                    char *buf, const size_t buflen)

{

    if (idx >= STATICARRAYLEN(ctx->source_args))

    {

        fail(ctx, "Too many source args");

        *buf = '\0';

        return buf;

    } // if

    const SourceArgInfo *arg = &ctx->source_args[idx];

    return get_ARB1_varname_in_buf(ctx, arg->regtype, arg->regnum, buf, buflen);

} // get_ARB1_srcarg_varname

const char *make_ARB1_destarg_string(Context *ctx, char *buf,

                                     const size_t buflen)

{

    const DestArgInfo *arg = &ctx->dest_arg;

    *buf = '\0';

    const char *sat_str = "";

    if (arg->result_mod & MOD_SATURATE)

    {

        // nv4 can use ".SAT" in all program types.

        // For less than nv4, the "_SAT" modifier is only available in

        //  fragment shaders. Every thing else will fake it later in

        //  emit_ARB1_dest_modifiers() ...

        if (support_nv4(ctx))

            sat_str = ".SAT";

        else if (shader_is_pixel(ctx))

            sat_str = "_SAT";

    } // if

    const char *pp_str = "";

    if (arg->result_mod & MOD_PP)

    {

        // Most ARB1 profiles can't do partial precision (MOD_PP), but that's

        //  okay. The spec says lots of Direct3D implementations ignore the

        //  flag anyhow.

        if (support_nv4(ctx))

            pp_str = "H";

    } // if

    // CENTROID only allowed in DCL opcodes, which shouldn't come through here.

    assert((arg->result_mod & MOD_CENTROID) == 0);

    char regnum_str[16];

    const char *regtype_str = get_ARB1_register_string(ctx, arg->regtype,

                                                       arg->regnum, regnum_str,

                                                       sizeof (regnum_str));

    if (regtype_str == NULL)

    {

        fail(ctx, "Unknown destination register type.");

        return buf;

    } // if

    char writemask_str[6];

    size_t i = 0;

    const int scalar = isscalar(ctx, ctx->shader_type, arg->regtype, arg->regnum);

    if (!scalar && !writemask_xyzw(arg->writemask))

    {

        writemask_str[i++] = '.';

        if (arg->writemask0) writemask_str[i++] = 'x';

        if (arg->writemask1) writemask_str[i++] = 'y';

        if (arg->writemask2) writemask_str[i++] = 'z';

        if (arg->writemask3) writemask_str[i++] = 'w';

    } // if

    writemask_str[i] = '\0';

    assert(i < sizeof (writemask_str));

    //const char *pred_left = "";

    //const char *pred_right = "";

    char pred[32] = { '\0' };

    if (ctx->predicated)

    {

        fail(ctx, "dest register predication currently unsupported in arb1");

        return buf;

        //pred_left = "(";

        //pred_right = ") ";

        make_ARB1_srcarg_string_in_buf(ctx, &ctx->predicate_arg,

                                       pred, sizeof (pred));

    } // if

    snprintf(buf, buflen, "%s%s %s%s%s", pp_str, sat_str,

             regtype_str, regnum_str, writemask_str);

    // !!! FIXME: make sure the scratch buffer was large enough.

    return buf;

} // make_ARB1_destarg_string

void emit_ARB1_dest_modifiers(Context *ctx)

{

    const DestArgInfo *arg = &ctx->dest_arg;

    if (arg->result_shift != 0x0)

    {

        char dst[64]; make_ARB1_destarg_string(ctx, dst, sizeof (dst));

        const char *multiplier = NULL;

        switch (arg->result_shift)

        {

            case 0x1: multiplier = "2.0"; break;

            case 0x2: multiplier = "4.0"; break;

            case 0x3: multiplier = "8.0"; break;

            case 0xD: multiplier = "0.125"; break;

            case 0xE: multiplier = "0.25"; break;

            case 0xF: multiplier = "0.5"; break;

        } // switch

        if (multiplier != NULL)

        {

            char var[64]; get_ARB1_destarg_varname(ctx, var, sizeof (var));

            output_line(ctx, "MUL%s, %s, %s;", dst, var, multiplier);

        } // if

    } // if

    if (arg->result_mod & MOD_SATURATE)

    {

        // nv4 and/or pixel shaders just used the "SAT" modifier, instead.

        if ( (!support_nv4(ctx)) && (!shader_is_pixel(ctx)) )

        {

            char var[64]; get_ARB1_destarg_varname(ctx, var, sizeof (var));

            char dst[64]; make_ARB1_destarg_string(ctx, dst, sizeof (dst));

            output_line(ctx, "MIN%s, %s, 1.0;", dst, var);

            output_line(ctx, "MAX%s, %s, 0.0;", dst, var);

        } // if

    } // if

} // emit_ARB1_dest_modifiers

const char *make_ARB1_srcarg_string(Context *ctx, const size_t idx,

                                    char *buf, const size_t buflen)

{

    if (idx >= STATICARRAYLEN(ctx->source_args))

    {

        fail(ctx, "Too many source args");

        *buf = '\0';

        return buf;

    } // if

    const SourceArgInfo *arg = &ctx->source_args[idx];

    return make_ARB1_srcarg_string_in_buf(ctx, arg, buf, buflen);

} // make_ARB1_srcarg_string

void emit_ARB1_opcode_ds(Context *ctx, const char *opcode)

{

    char dst[64]; make_ARB1_destarg_string(ctx, dst, sizeof (dst));

    char src0[64]; make_ARB1_srcarg_string(ctx, 0, src0, sizeof (src0));

    output_line(ctx, "%s%s, %s;", opcode, dst, src0);

    emit_ARB1_dest_modifiers(ctx);

} // emit_ARB1_opcode_ds

void emit_ARB1_opcode_dss(Context *ctx, const char *opcode)

{

    char dst[64]; make_ARB1_destarg_string(ctx, dst, sizeof (dst));

    char src0[64]; make_ARB1_srcarg_string(ctx, 0, src0, sizeof (src0));

    char src1[64]; make_ARB1_srcarg_string(ctx, 1, src1, sizeof (src1));

    output_line(ctx, "%s%s, %s, %s;", opcode, dst, src0, src1);

    emit_ARB1_dest_modifiers(ctx);

} // emit_ARB1_opcode_dss

void emit_ARB1_opcode_dsss(Context *ctx, const char *opcode)

{

    char dst[64]; make_ARB1_destarg_string(ctx, dst, sizeof (dst));

    char src0[64]; make_ARB1_srcarg_string(ctx, 0, src0, sizeof (src0));

    char src1[64]; make_ARB1_srcarg_string(ctx, 1, src1, sizeof (src1));

    char src2[64]; make_ARB1_srcarg_string(ctx, 2, src2, sizeof (src2));

    output_line(ctx, "%s%s, %s, %s, %s;", opcode, dst, src0, src1, src2);

    emit_ARB1_dest_modifiers(ctx);

} // emit_ARB1_opcode_dsss

#define EMIT_ARB1_OPCODE_FUNC(op) \

    void emit_ARB1_##op(Context *ctx) { \

        emit_ARB1_opcode(ctx, #op); \

    }

#define EMIT_ARB1_OPCODE_D_FUNC(op) \

    void emit_ARB1_##op(Context *ctx) { \

        emit_ARB1_opcode_d(ctx, #op); \

    }

#define EMIT_ARB1_OPCODE_S_FUNC(op) \

    void emit_ARB1_##op(Context *ctx) { \

        emit_ARB1_opcode_s(ctx, #op); \

    }

#define EMIT_ARB1_OPCODE_SS_FUNC(op) \

    void emit_ARB1_##op(Context *ctx) { \

        emit_ARB1_opcode_ss(ctx, #op); \

    }

#define EMIT_ARB1_OPCODE_DS_FUNC(op) \

    void emit_ARB1_##op(Context *ctx) { \

        emit_ARB1_opcode_ds(ctx, #op); \

    }

#define EMIT_ARB1_OPCODE_DSS_FUNC(op) \

    void emit_ARB1_##op(Context *ctx) { \

        emit_ARB1_opcode_dss(ctx, #op); \

    }

#define EMIT_ARB1_OPCODE_DSSS_FUNC(op) \

    void emit_ARB1_##op(Context *ctx) { \

        emit_ARB1_opcode_dsss(ctx, #op); \

    }

#define EMIT_ARB1_OPCODE_DSSSS_FUNC(op) \

    void emit_ARB1_##op(Context *ctx) { \

        emit_ARB1_opcode_dssss(ctx, #op); \