/**

 * 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: I keep changing coding styles for symbols and typedefs.

// !!! FIXME: do DEF* opcodes have to come before instructions?

// !!! FIXME:  my reading of the msdn spec suggests no, but it sounds like

// !!! FIXME:  something they'd require. DCL_* _does_ have to be first.

// Shader bytecode format is described at MSDN:

//  http://msdn2.microsoft.com/en-us/library/ms800307.aspx

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <stdint.h>

#include <stdarg.h>

#include <assert.h>

#include "mojoshader.h"

// This is the highest shader version we currently support.

#define MAX_SHADER_MAJOR 3

#define MAX_SHADER_MINOR 0

// If SUPPORT_PROFILE_* isn't defined, we assume an implicit desire to support.

//  You get all the profiles unless you go out of your way to disable them.

#ifndef SUPPORT_PROFILE_D3D

#define SUPPORT_PROFILE_D3D 1

#endif

#ifndef SUPPORT_PROFILE_GLSL

#define SUPPORT_PROFILE_GLSL 1

#endif

// Get basic wankery out of the way here...

typedef unsigned int uint;  // this is a printf() helper. don't use for code.

typedef uint8_t uint8;

typedef uint32_t uint32;

typedef int32_t int32;

#ifdef __GNUC__

#define ISPRINTF(x,y) __attribute__((format (printf, x, y)))

#else

#define ISPRINTF(x,y)

#endif

#define STATICARRAYLEN(x) ( (sizeof ((x))) / (sizeof ((x)[0])) )

#ifdef _WINDOWS  // !!! FIXME: bleh

const char *endline_str = "\r\n";

#else

const char *endline_str = "\n";

#endif

// we need to reference this by explicit value occasionally.

#define OPCODE_RET 28

// Byteswap magic...

#if ((defined __GNUC__) && (defined __POWERPC__))

    static inline uint32 SWAP32(uint32 x)

    {

        __asm__ __volatile__("lwbrx %0,0,%1" : "=r" (x) : "r" (&x));

        return x;

    } // SWAP32

#elif defined(__POWERPC__)

    static inline uint32 SWAP32(uint32 x)

    {

        return ( (((x) >> 24) & 0x000000FF) | (((x) >>  8) & 0x0000FF00) |

                 (((x) <<  8) & 0x00FF0000) | (((x) << 24) & 0xFF000000) );

    } // SWAP32

#else

#   define SWAP32(x) (x)

#endif

// predeclare.

typedef struct Context Context;

// one emit function for each opcode in each profile.

typedef void (*emit_function)(Context *ctx);

// one emit function for comments in each profile.

typedef void (*emit_comment)(Context *ctx, const char *str);

// one emit function for starting output in each profile.

typedef void (*emit_start)(Context *ctx);

// one emit function for ending output in each profile.

typedef void (*emit_end)(Context *ctx);

// one args function for each possible sequence of opcode arguments.

typedef int (*args_function)(Context *ctx);

// one state function for each opcode where we have state machine updates.

typedef void (*state_function)(Context *ctx);

typedef struct

{

    const char *name;

    emit_start start_emitter;

    emit_end end_emitter;

    emit_comment comment_emitter;

} Profile;

typedef MOJOSHADER_shaderType ShaderType;

typedef enum

{

    REGISTER_TYPE_TEMP = 0,

    REGISTER_TYPE_INPUT = 1,

    REGISTER_TYPE_CONST = 2,

    REGISTER_TYPE_ADDRESS = 3,

    REGISTER_TYPE_TEXTURE = 3,  // ALSO 3!

    REGISTER_TYPE_RASTOUT = 4,

    REGISTER_TYPE_ATTROUT = 5,

    REGISTER_TYPE_TEXCRDOUT = 6,

    REGISTER_TYPE_OUTPUT = 6,  // ALSO 6!

    REGISTER_TYPE_CONSTINT = 7,

    REGISTER_TYPE_COLOROUT = 8,

    REGISTER_TYPE_DEPTHOUT = 9,

    REGISTER_TYPE_SAMPLER = 10,

    REGISTER_TYPE_CONST2 = 11,

    REGISTER_TYPE_CONST3 = 12,

    REGISTER_TYPE_CONST4 = 13,

    REGISTER_TYPE_CONSTBOOL = 14,

    REGISTER_TYPE_LOOP = 15,

    REGISTER_TYPE_TEMPFLOAT16 = 16,

    REGISTER_TYPE_MISCTYPE = 17,

    REGISTER_TYPE_LABEL = 18,

    REGISTER_TYPE_PREDICATE = 19,

    REGISTER_TYPE_MAX = 19

} RegisterType;

typedef enum

{

    RASTOUT_TYPE_POSITION = 0,

    RASTOUT_TYPE_FOG = 1,

    RASTOUT_TYPE_POINT_SIZE = 2,

    RASTOUT_TYPE_MAX = 2

} RastOutType;

typedef enum

{

    MISCTYPE_TYPE_POSITION = 0,

    MISCTYPE_TYPE_FACE = 1,

    MISCTYPE_TYPE_MAX = 1

} MiscTypeType;

typedef enum

{

    DECLUSAGE_POSITION = 0,

    DECLUSAGE_BLENDWEIGHT = 1,

    DECLUSAGE_BLENDINDICES = 2,

    DECLUSAGE_NORMAL = 3,

    DECLUSAGE_PSIZE = 4,

    DECLUSAGE_TEXCOORD = 5,

    DECLUSAGE_TANGENT = 6,

    DECLUSAGE_BINORMAL = 7,

    DECLUSAGE_TESSFACTOR = 8,

    DECLUSAGE_POSITIONT = 9,

    DECLUSAGE_COLOR = 10,

    DECLUSAGE_FOG = 11,

    DECLUSAGE_DEPTH = 12,

    DECLUSAGE_SAMPLE = 13

} DeclUsageType;

typedef enum

{

    TEXTURE_TYPE_2D = 2,

    TEXTURE_TYPE_CUBE = 3,

    TEXTURE_TYPE_VOLUME = 4,

} TextureType;

// A simple linked list of strings, so we can build the final output without

//  realloc()ing for each new line, and easily insert lines into the middle

//  of the output without much trouble.

typedef struct OutputListNode

{

    char *str;

    struct OutputListNode *next;

} OutputListNode;

typedef struct OutputList

{

    OutputListNode head;

    OutputListNode *tail;

} OutputList;

// result modifiers.

#define MOD_SATURATE 0x01

#define MOD_PP 0x02

#define MOD_CENTROID 0x04

// source modifiers.

typedef enum

{

    SRCMOD_NONE,

    SRCMOD_NEGATE,

    SRCMOD_BIAS,

    SRCMOD_BIASNEGATE,

    SRCMOD_SIGN,

    SRCMOD_SIGNNEGATE,

    SRCMOD_COMPLEMENT,

    SRCMOD_X2,

    SRCMOD_X2NEGATE,

    SRCMOD_DZ,

    SRCMOD_DW,

    SRCMOD_ABS,

    SRCMOD_ABSNEGATE,

    SRCMOD_NOT,

    SRCMOD_TOTAL

} SourceMod;

typedef struct

{

    const uint32 *token;   // this is the unmolested token in the stream.

    int regnum;

    int relative;

    int writemask;   // xyzw or rgba (all four, not split out).

    int writemask0;  // x or red

    int writemask1;  // y or green

    int writemask2;  // z or blue

    int writemask3;  // w or alpha

    int result_mod;

    int result_shift;

    RegisterType regtype;

} DestArgInfo;

typedef struct

{

    const uint32 *token;   // this is the unmolested token in the stream.

    int regnum;

    int relative;

    int swizzle;  // xyzw (all four, not split out).

    int swizzle_x;

    int swizzle_y;

    int swizzle_z;

    int swizzle_w;

    int src_mod;

    RegisterType regtype;

} SourceArgInfo;

typedef enum

{

    CTX_FLAGS_GLSL_LIT_OPCODE = (1 << 0),

    CTX_FLAGS_GLSL_DST_OPCODE = (1 << 1),

    CTX_FLAGS_GLSL_LRP_OPCODE = (1 << 2),

    CTX_FLAGS_MASK = 0xFFFFFFFF

} ContextFlags;

#define SCRATCH_BUFFER_SIZE 256

#define SCRATCH_BUFFERS 10

// !!! FIXME: labels_called and the scratch buffers make this pretty big.

// !!! FIXME:  might be worth having one set of static scratch buffers that

// !!! FIXME:  are mutex protected?

// !!! FIXME: and replace the bit array for labels_called with a linked list?

// !!! FIXME:  maybe just malloc() the label list, since it can't be more than

// !!! FIXME:  around (bytes_of_shader / 20) elements in the pathological case?

// Context...this is state that changes as we parse through a shader...

struct Context

{

    MOJOSHADER_malloc malloc;

    MOJOSHADER_free free;

    const uint32 *tokens;

    uint32 tokencount;

    OutputList *output;

    OutputList globals;

    OutputList helpers;

    OutputList subroutines;

    OutputList mainline;

    OutputList ignore;

    OutputList *output_stack[2];

    int indent_stack[2];

    int output_stack_len;

    int output_len; // total strlen; prevents walking the lists just to malloc.

    int indent;

    const char *endline;

    int endline_len;

    const char *failstr;

    char scratch[SCRATCH_BUFFERS][SCRATCH_BUFFER_SIZE];

    int scratchidx;  // current scratch buffer.

    int profileid;

    const Profile *profile;

    ShaderType shader_type;

    uint8 major_ver;

    uint8 minor_ver;

    DestArgInfo dest_args[1];

    SourceArgInfo source_args[5];

    uint32 dwords[4];

    int instruction_count;

    uint32 instruction_controls;

    uint32 previous_opcode;

    ContextFlags flags;

    uint8 labels_called[256];

    int loops;

};

// jump between output sections in the context...

static inline void push_output(Context *ctx, OutputList *section)

{

    assert(ctx->output_stack_len < STATICARRAYLEN(ctx->output_stack));

    ctx->output_stack[ctx->output_stack_len] = ctx->output;

    ctx->indent_stack[ctx->output_stack_len] = ctx->indent;

    ctx->output_stack_len++;

    ctx->output = section;

    ctx->indent = 0;

} // push_output

static inline void pop_output(Context *ctx)

{

    assert(ctx->output_stack_len > 0);

    ctx->output_stack_len--;

    ctx->output = ctx->output_stack[ctx->output_stack_len];

    ctx->indent = ctx->indent_stack[ctx->output_stack_len];

} // pop_output

// Shader model version magic...

static inline uint32 ver_ui32(const uint8 major, const uint8 minor)

{

    return ( (((uint32) major) << 16) | (((minor) == 0xFF) ? 0 : (minor)) );

} // version_ui32

static int shader_version_supported(uint8 maj, uint8 min)

{

    return (ver_ui32(maj,min) <= ver_ui32(MAX_SHADER_MAJOR, MAX_SHADER_MINOR));

} // shader_version_supported

static int shader_version_atleast(const Context *ctx, uint8 maj, uint8 min)

{

    return (ver_ui32(ctx->major_ver, ctx->minor_ver) >= ver_ui32(maj, min));

} // shader_version_atleast

// Bit arrays (for storing large arrays of booleans...

static void set_bit_array(uint8 *array, size_t arraylen, int index, int val)

{

    const int byteindex = index / 8;

    const int bitindex = index % 8;

    assert(byteindex < arraylen);

    if (val)

        array[byteindex] |= (1 << bitindex);

    else

        array[byteindex] &= ~(1 << bitindex);

} // set_bit_array

static int get_bit_array(const uint8 *array, size_t arraylen, int index)

{

    const int byteindex = index / 8;

    const int bitindex = index % 8;

    assert(byteindex < arraylen);

    const uint8 byte = array[byteindex];

    return (byte & (1 << bitindex)) ? 1 : 0;

} // get_bit_array

static inline char *get_scratch_buffer(Context *ctx)

{

    ctx->scratchidx = (ctx->scratchidx + 1) % SCRATCH_BUFFERS;

    return ctx->scratch[ctx->scratchidx];

} // get_scratch_buffer

// Special-case return values from the parsing pipeline...

#define FAIL (-1)

#define NOFAIL (-2)

#define END_OF_STREAM (-3)

static inline int isfail(const Context *ctx)

{

    return (ctx->failstr != NULL);

} // isfail

static MOJOSHADER_parseData out_of_mem_data = {

    "Out of memory", 0, 0, 0, MOJOSHADER_TYPE_UNKNOWN, 0, 0, 0, 0

};

static const char *out_of_mem_str = "Out of memory";

static inline int out_of_memory(Context *ctx)

{

    if (ctx->failstr == NULL)

        ctx->failstr = out_of_mem_str;  // fail() would call malloc().

    return FAIL;

} // out_of_memory

static int failf(Context *ctx, const char *fmt, ...) ISPRINTF(2,3);

static int failf(Context *ctx, const char *fmt, ...)

{

    if (ctx->failstr == NULL)  // don't change existing error.

    {

        char *scratch = get_scratch_buffer(ctx);

        va_list ap;

        va_start(ap, fmt);

        const int len = vsnprintf(scratch,SCRATCH_BUFFER_SIZE,fmt,ap);

        va_end(ap);

        char *failstr = (char *) ctx->malloc(len + 1);

        if (failstr == NULL)

            out_of_memory(ctx);

        else

        {

            // see comments about scratch buffer overflow in output_line().

            if (len < SCRATCH_BUFFER_SIZE)

                strcpy(failstr, scratch);  // copy it over.

            else

            {

                va_start(ap, fmt);

                vsnprintf(failstr, len + 1, fmt, ap);  // rebuild it.

                va_end(ap);

            } // else

            ctx->failstr = failstr;

        } // else

    } // if

    return FAIL;

} // failf

static inline int fail(Context *ctx, const char *reason)

{

    return failf(ctx, "%s", reason);

} // fail

static int output_line(Context *ctx, const char *fmt, ...) ISPRINTF(2,3);

static int output_line(Context *ctx, const char *fmt, ...)

{

    OutputListNode *item = NULL;

    if (isfail(ctx))

        return FAIL;  // we failed previously, don't go on...

    char *scratch = get_scratch_buffer(ctx);

    const int indent = ctx->indent;

    if (indent > 0)

        memset(scratch, '\t', indent);

    va_list ap;

    va_start(ap, fmt);

    const int len = vsnprintf(scratch+indent, SCRATCH_BUFFER_SIZE-indent, fmt, ap) + indent;

    va_end(ap);

    item = (OutputListNode *) ctx->malloc(sizeof (OutputListNode));

    if (item == NULL)

        return out_of_memory(ctx);

    item->str = (char *) ctx->malloc(len + 1);

    if (item->str == NULL)

    {

        free(item);

        return out_of_memory(ctx);

    } // if

    // If we overflowed our scratch buffer, that's okay. We were going to