/**

 * 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.

 */

// !!! FIXME: this file really needs to be split up.

// !!! FIXME: I keep changing coding styles for symbols and typedefs.

// !!! FIXME: rules from MSDN about temp registers we probably don't check.

// - There are limited temporaries: vs_1_1 has 12 (ps_1_1 has _2_!).

// - SM2 apparently was variable, between 12 and 32. Shader Model 3 has 32.

// - A maximum of three temp registers can be used in a single instruction.

#define __MOJOSHADER_INTERNAL__ 1

#include "profiles/mojoshader_profile.h"

// Deal with register lists...  !!! FIXME: I sort of hate this.

static void free_reglist(MOJOSHADER_free f, void *d, RegisterList *item)

{

    while (item != NULL)

    {

        RegisterList *next = item->next;

        f(item, d);

        item = next;

    } // while

} // free_reglist

static inline const RegisterList *reglist_exists(RegisterList *prev,

                                                 const RegisterType regtype,

                                                 const int regnum)

{

    return (reglist_find(prev, regtype, regnum));

} // reglist_exists

static inline int register_was_written(Context *ctx, const RegisterType rtype,

                                       const int regnum)

{

    RegisterList *reg = reglist_find(&ctx->used_registers, rtype, regnum);

    return (reg && reg->written);

} // register_was_written

static inline int get_defined_register(Context *ctx, const RegisterType rtype,

                                       const int regnum)

{

    return (reglist_exists(&ctx->defined_registers, rtype, regnum) != NULL);

} // get_defined_register

static void add_attribute_register(Context *ctx, const RegisterType rtype,

                                const int regnum, const MOJOSHADER_usage usage,

                                const int index, const int writemask, int flags)

{

    RegisterList *item = reglist_insert(ctx, &ctx->attributes, rtype, regnum);

    item->usage = usage;

    item->index = index;

    item->writemask = writemask;

    item->misc = flags;

    if ((rtype == REG_TYPE_OUTPUT) && (usage == MOJOSHADER_USAGE_POINTSIZE))

        ctx->uses_pointsize = 1;  // note that we have to check this later.

    else if ((rtype == REG_TYPE_OUTPUT) && (usage == MOJOSHADER_USAGE_FOG))

        ctx->uses_fog = 1;  // note that we have to check this later.

} // add_attribute_register

static inline TextureType cvtMojoToD3DSamplerType(const MOJOSHADER_samplerType type)

{

    return (TextureType) (((int) type) + 2);

} // cvtMojoToD3DSamplerType

static inline MOJOSHADER_samplerType cvtD3DToMojoSamplerType(const TextureType type)

{

    return (MOJOSHADER_samplerType) (((int) type) - 2);

} // cvtD3DToMojoSamplerType

static inline void add_sampler(Context *ctx, const int regnum,

                               TextureType ttype, const int texbem)

{

    const RegisterType rtype = REG_TYPE_SAMPLER;

    // !!! FIXME: make sure it doesn't exist?

    // !!! FIXME:  (ps_1_1 assume we can add it multiple times...)

    RegisterList *item = reglist_insert(ctx, &ctx->samplers, rtype, regnum);

    if (ctx->samplermap != NULL)

    {

        unsigned int i;

        for (i = 0; i < ctx->samplermap_count; i++)

        {

            if (ctx->samplermap[i].index == regnum)

            {

                ttype = cvtMojoToD3DSamplerType(ctx->samplermap[i].type);

                break;

            } // if

        } // for

    } // if

    item->index = (int) ttype;

    item->misc |= texbem;

} // add_sampler

static inline void adjust_token_position(Context *ctx, const int incr)

{

    ctx->tokens += incr;

    ctx->tokencount -= incr;

    ctx->current_position += incr * sizeof (uint32);

} // adjust_token_position

// Generate emitter declarations for each profile with this macro...

#define PREDECLARE_PROFILE(prof) \

    void emit_##prof##_start(Context *ctx, const char *profilestr); \

    void emit_##prof##_end(Context *ctx); \

    void emit_##prof##_phase(Context *ctx); \

    void emit_##prof##_finalize(Context *ctx); \

    void emit_##prof##_global(Context *ctx, RegisterType regtype, int regnum);\

    void emit_##prof##_array(Context *ctx, VariableList *var); \

    void emit_##prof##_const_array(Context *ctx, const ConstantsList *clist, \

                                   int base, int size); \

    void emit_##prof##_uniform(Context *ctx, RegisterType regtype, int regnum,\

                               const VariableList *var); \

    void emit_##prof##_sampler(Context *ctx, int stage, TextureType ttype, \

                               int tb); \

    void emit_##prof##_attribute(Context *ctx, RegisterType regtype, \

                                 int regnum, MOJOSHADER_usage usage, \

                                 int index, int wmask, int flags); \

    void emit_##prof##_NOP(Context *ctx); \

    void emit_##prof##_MOV(Context *ctx); \

    void emit_##prof##_ADD(Context *ctx); \

    void emit_##prof##_SUB(Context *ctx); \

    void emit_##prof##_MAD(Context *ctx); \

    void emit_##prof##_MUL(Context *ctx); \

    void emit_##prof##_RCP(Context *ctx); \

    void emit_##prof##_RSQ(Context *ctx); \

    void emit_##prof##_DP3(Context *ctx); \

    void emit_##prof##_DP4(Context *ctx); \

    void emit_##prof##_MIN(Context *ctx); \

    void emit_##prof##_MAX(Context *ctx); \

    void emit_##prof##_SLT(Context *ctx); \

    void emit_##prof##_SGE(Context *ctx); \

    void emit_##prof##_EXP(Context *ctx); \

    void emit_##prof##_LOG(Context *ctx); \

    void emit_##prof##_LIT(Context *ctx); \

    void emit_##prof##_DST(Context *ctx); \

    void emit_##prof##_LRP(Context *ctx); \

    void emit_##prof##_FRC(Context *ctx); \

    void emit_##prof##_M4X4(Context *ctx); \

    void emit_##prof##_M4X3(Context *ctx); \

    void emit_##prof##_M3X4(Context *ctx); \

    void emit_##prof##_M3X3(Context *ctx); \

    void emit_##prof##_M3X2(Context *ctx); \

    void emit_##prof##_CALL(Context *ctx); \

    void emit_##prof##_CALLNZ(Context *ctx); \

    void emit_##prof##_LOOP(Context *ctx); \

    void emit_##prof##_ENDLOOP(Context *ctx); \

    void emit_##prof##_LABEL(Context *ctx); \

    void emit_##prof##_DCL(Context *ctx); \

    void emit_##prof##_POW(Context *ctx); \

    void emit_##prof##_CRS(Context *ctx); \

    void emit_##prof##_SGN(Context *ctx); \

    void emit_##prof##_ABS(Context *ctx); \

    void emit_##prof##_NRM(Context *ctx); \

    void emit_##prof##_SINCOS(Context *ctx); \

    void emit_##prof##_REP(Context *ctx); \

    void emit_##prof##_ENDREP(Context *ctx); \

    void emit_##prof##_IF(Context *ctx); \

    void emit_##prof##_IFC(Context *ctx); \

    void emit_##prof##_ELSE(Context *ctx); \

    void emit_##prof##_ENDIF(Context *ctx); \

    void emit_##prof##_BREAK(Context *ctx); \

    void emit_##prof##_BREAKC(Context *ctx); \

    void emit_##prof##_MOVA(Context *ctx); \

    void emit_##prof##_DEFB(Context *ctx); \

    void emit_##prof##_DEFI(Context *ctx); \

    void emit_##prof##_TEXCRD(Context *ctx); \

    void emit_##prof##_TEXKILL(Context *ctx); \

    void emit_##prof##_TEXLD(Context *ctx); \

    void emit_##prof##_TEXBEM(Context *ctx); \

    void emit_##prof##_TEXBEML(Context *ctx); \

    void emit_##prof##_TEXREG2AR(Context *ctx); \

    void emit_##prof##_TEXREG2GB(Context *ctx); \

    void emit_##prof##_TEXM3X2PAD(Context *ctx); \

    void emit_##prof##_TEXM3X2TEX(Context *ctx); \

    void emit_##prof##_TEXM3X3PAD(Context *ctx); \

    void emit_##prof##_TEXM3X3TEX(Context *ctx); \

    void emit_##prof##_TEXM3X3SPEC(Context *ctx); \

    void emit_##prof##_TEXM3X3VSPEC(Context *ctx); \

    void emit_##prof##_EXPP(Context *ctx); \

    void emit_##prof##_LOGP(Context *ctx); \

    void emit_##prof##_CND(Context *ctx); \

    void emit_##prof##_DEF(Context *ctx); \

    void emit_##prof##_TEXREG2RGB(Context *ctx); \

    void emit_##prof##_TEXDP3TEX(Context *ctx); \

    void emit_##prof##_TEXM3X2DEPTH(Context *ctx); \

    void emit_##prof##_TEXDP3(Context *ctx); \

    void emit_##prof##_TEXM3X3(Context *ctx); \

    void emit_##prof##_TEXDEPTH(Context *ctx); \

    void emit_##prof##_CMP(Context *ctx); \

    void emit_##prof##_BEM(Context *ctx); \

    void emit_##prof##_DP2ADD(Context *ctx); \

    void emit_##prof##_DSX(Context *ctx); \

    void emit_##prof##_DSY(Context *ctx); \

    void emit_##prof##_TEXLDD(Context *ctx); \

    void emit_##prof##_SETP(Context *ctx); \

    void emit_##prof##_TEXLDL(Context *ctx); \

    void emit_##prof##_BREAKP(Context *ctx); \

    void emit_##prof##_RESERVED(Context *ctx); \

    void emit_##prof##_RET(Context *ctx); \

    const char *get_##prof##_varname(Context *ctx, RegisterType rt, \

                                     int regnum); \

    const char *get_##prof##_const_array_varname(Context *ctx, \

                                                 int base, int size);

// Check for profile support...

#define AT_LEAST_ONE_PROFILE 0

#if !SUPPORT_PROFILE_BYTECODE

#define PROFILE_EMITTER_BYTECODE(op)

#else

#undef AT_LEAST_ONE_PROFILE

#define AT_LEAST_ONE_PROFILE 1

#define PROFILE_EMITTER_BYTECODE(op) emit_BYTECODE_##op,

PREDECLARE_PROFILE(BYTECODE)

#endif

#if !SUPPORT_PROFILE_D3D

#define PROFILE_EMITTER_D3D(op)

#else

#undef AT_LEAST_ONE_PROFILE

#define AT_LEAST_ONE_PROFILE 1

#define PROFILE_EMITTER_D3D(op) emit_D3D_##op,

PREDECLARE_PROFILE(D3D)

#endif

#if !SUPPORT_PROFILE_HLSL

#define PROFILE_EMITTER_HLSL(op)

#else

#undef AT_LEAST_ONE_PROFILE

#define AT_LEAST_ONE_PROFILE 1

#define PROFILE_EMITTER_HLSL(op) emit_HLSL_##op,

PREDECLARE_PROFILE(HLSL)

#endif

#if !SUPPORT_PROFILE_GLSL

#define PROFILE_EMITTER_GLSL(op)

#else

#undef AT_LEAST_ONE_PROFILE

#define AT_LEAST_ONE_PROFILE 1

#define PROFILE_EMITTER_GLSL(op) emit_GLSL_##op,

PREDECLARE_PROFILE(GLSL)

#endif

#if !SUPPORT_PROFILE_METAL

#define PROFILE_EMITTER_METAL(op)

#else

#undef AT_LEAST_ONE_PROFILE

#define AT_LEAST_ONE_PROFILE 1

#define PROFILE_EMITTER_METAL(op) emit_METAL_##op,

PREDECLARE_PROFILE(METAL)

#endif

#if !SUPPORT_PROFILE_ARB1

#define PROFILE_EMITTER_ARB1(op)

#else

#undef AT_LEAST_ONE_PROFILE

#define AT_LEAST_ONE_PROFILE 1

#define PROFILE_EMITTER_ARB1(op) emit_ARB1_##op,

PREDECLARE_PROFILE(ARB1)

#endif

#if !SUPPORT_PROFILE_SPIRV

#define PROFILE_EMITTER_SPIRV(op)

#else

#undef AT_LEAST_ONE_PROFILE

#define AT_LEAST_ONE_PROFILE 1

#define PROFILE_EMITTER_SPIRV(op) emit_SPIRV_##op,

PREDECLARE_PROFILE(SPIRV)

#endif

#if !AT_LEAST_ONE_PROFILE

#error No profiles are supported. Fix your build.

#endif

#define DEFINE_PROFILE(prof) { \

    MOJOSHADER_PROFILE_##prof, \

    emit_##prof##_start, \

    emit_##prof##_end, \

    emit_##prof##_phase, \

    emit_##prof##_global, \

    emit_##prof##_array, \

    emit_##prof##_const_array, \

    emit_##prof##_uniform, \

    emit_##prof##_sampler, \

    emit_##prof##_attribute, \

    emit_##prof##_finalize, \

    get_##prof##_varname, \

    get_##prof##_const_array_varname, \

},

static const Profile profiles[] =

{

#if SUPPORT_PROFILE_D3D

    DEFINE_PROFILE(D3D)

#endif

#if SUPPORT_PROFILE_BYTECODE

    DEFINE_PROFILE(BYTECODE)

#endif

#if SUPPORT_PROFILE_HLSL

    DEFINE_PROFILE(HLSL)

#endif

#if SUPPORT_PROFILE_GLSL

    DEFINE_PROFILE(GLSL)

#endif

#if SUPPORT_PROFILE_ARB1

    DEFINE_PROFILE(ARB1)

#endif

#if SUPPORT_PROFILE_METAL

    DEFINE_PROFILE(METAL)

#endif

#if SUPPORT_PROFILE_SPIRV

    DEFINE_PROFILE(SPIRV)

#endif

};

#undef DEFINE_PROFILE

// This is for profiles that extend other profiles...

static const struct { const char *from; const char *to; } profileMap[] =

{

    { MOJOSHADER_PROFILE_GLSPIRV, MOJOSHADER_PROFILE_SPIRV },

    { MOJOSHADER_PROFILE_GLSLES, MOJOSHADER_PROFILE_GLSL },

    { MOJOSHADER_PROFILE_GLSL120, MOJOSHADER_PROFILE_GLSL },

    { MOJOSHADER_PROFILE_NV2, MOJOSHADER_PROFILE_ARB1 },

    { MOJOSHADER_PROFILE_NV3, MOJOSHADER_PROFILE_ARB1 },

    { MOJOSHADER_PROFILE_NV4, MOJOSHADER_PROFILE_ARB1 },

};

// The PROFILE_EMITTER_* items MUST be in the same order as profiles[]!

#define PROFILE_EMITTERS(op) { \

     PROFILE_EMITTER_D3D(op) \

     PROFILE_EMITTER_BYTECODE(op) \

     PROFILE_EMITTER_HLSL(op) \

     PROFILE_EMITTER_GLSL(op) \

     PROFILE_EMITTER_ARB1(op) \

     PROFILE_EMITTER_METAL(op) \

     PROFILE_EMITTER_SPIRV(op) \

}

static int parse_destination_token(Context *ctx, DestArgInfo *info)

{

    // !!! FIXME: recheck against the spec for ranges (like RASTOUT values, etc).

    if (ctx->tokencount == 0)

    {

        fail(ctx, "Out of tokens in destination parameter");

        return 0;

    } // if

    const uint32 token = SWAP32(*(ctx->tokens));

    const int reserved1 = (int) ((token >> 14) & 0x3); // bits 14 through 15

    const int reserved2 = (int) ((token >> 31) & 0x1); // bit 31

    info->token = ctx->tokens;

    info->regnum = (int) (token & 0x7ff);  // bits 0 through 10

    info->relative = (int) ((token >> 13) & 0x1); // bit 13

    info->orig_writemask = (int) ((token >> 16) & 0xF); // bits 16 through 19

    info->result_mod = (int) ((token >> 20) & 0xF); // bits 20 through 23

    info->result_shift = (int) ((token >> 24) & 0xF); // bits 24 through 27      abc

    info->regtype = (RegisterType) (((token >> 28) & 0x7) | ((token >> 8) & 0x18));  // bits 28-30, 11-12

    int writemask;

    if (isscalar(ctx, ctx->shader_type, info->regtype, info->regnum))

        writemask = 0x1;  // just x.

    else

        writemask = info->orig_writemask;

    set_dstarg_writemask(info, writemask);  // bits 16 through 19.

    // all the REG_TYPE_CONSTx types are the same register type, it's just

    //  split up so its regnum can be > 2047 in the bytecode. Clean it up.

    if (info->regtype == REG_TYPE_CONST2)

    {

        info->regtype = REG_TYPE_CONST;

        info->regnum += 2048;

    } // else if

    else if (info->regtype == REG_TYPE_CONST3)

    {

        info->regtype = REG_TYPE_CONST;

        info->regnum += 4096;

    } // else if

    else if (info->regtype == REG_TYPE_CONST4)

    {

        info->regtype = REG_TYPE_CONST;

        info->regnum += 6144;

    } // else if

    // swallow token for now, for multiple calls in a row.

    adjust_token_position(ctx, 1);

    if (reserved1 != 0x0)

        fail(ctx, "Reserved bit #1 in destination token must be zero");

    if (reserved2 != 0x1)

        fail(ctx, "Reserved bit #2 in destination token must be one");

    if (info->relative)

    {

        if (!shader_is_vertex(ctx))

            fail(ctx, "Relative addressing in non-vertex shader");

        if (!shader_version_atleast(ctx, 3, 0))

            fail(ctx, "Relative addressing in vertex shader version < 3.0");

        if ((!ctx->ctab.have_ctab) && (!ctx->ignores_ctab))

        {

            // it's hard to do this efficiently without!

            fail(ctx, "relative addressing unsupported without a CTAB");

        } // if

        // !!! FIXME: I don't have a shader that has a relative dest currently.

        fail(ctx, "Relative addressing of dest tokens is unsupported");

        return 2;

    } // if

    const int s = info->result_shift;

    if (s != 0)

    {

        if (!shader_is_pixel(ctx))

            fail(ctx, "Result shift scale in non-pixel shader");

        if (shader_version_atleast(ctx, 2, 0))

            fail(ctx, "Result shift scale in pixel shader version >= 2.0");

        if ( ! (((s >= 1) && (s <= 3)) || ((s >= 0xD) && (s <= 0xF))) )

            fail(ctx, "Result shift scale isn't 1 to 3, or 13 to 15.");

    } // if

    if (info->result_mod & MOD_PP)  // Partial precision (pixel shaders only)

    {

        if (!shader_is_pixel(ctx))

            fail(ctx, "Partial precision result mod in non-pixel shader");

    } // if

    if (info->result_mod & MOD_CENTROID)  // Centroid (pixel shaders only)

    {

        if (!shader_is_pixel(ctx))

            fail(ctx, "Centroid result mod in non-pixel shader");

        else if (!ctx->centroid_allowed)  // only on DCL opcodes!

            fail(ctx, "Centroid modifier not allowed here");

    } // if

    if (/*(info->regtype < 0) ||*/ (info->regtype > REG_TYPE_MAX))

        fail(ctx, "Register type is out of range");

    if (!isfail(ctx))

        set_used_register(ctx, info->regtype, info->regnum, 1);

    return 1;

} // parse_destination_token

static void determine_constants_arrays(Context *ctx)

{

    // Only process this stuff once. This is called after all DEF* opcodes

    //  could have been parsed.

    if (ctx->determined_constants_arrays)

        return;

    ctx->determined_constants_arrays = 1;

    if (ctx->constant_count <= 1)

        return;  // nothing to sort or group.

    // Sort the linked list into an array for easier tapdancing...

    ConstantsList **array = (ConstantsList **) alloca(sizeof (ConstantsList *) * (ctx->constant_count + 1));

    ConstantsList *item = ctx->constants;

    int i;

    for (i = 0; i < ctx->constant_count; i++)

    {

        if (item == NULL)

        {

            fail(ctx, "BUG: mismatched constant list and count");

            return;

        } // if

        array[i] = item;