[3/3] d3dx9: Implement a basic bytecode writer. [try 4]

Matteo Bruni matteo.mystral at gmail.com
Mon Mar 29 11:19:34 CDT 2010


-------------- next part --------------
From 42eca440a49f2cb262e27e98c1234ae9530462cc Mon Sep 17 00:00:00 2001
From: Matteo Bruni <matteo.mystral at gmail.com>
Date: Mon, 29 Mar 2010 17:57:30 +0200
Subject: d3dx9: Implement a basic bytecode writer.

Now the shader assembler is structurally complete and it correctly
assembles one trivial shader program.
---
 dlls/d3dx9_36/asmutils.c         |   62 +++++++
 dlls/d3dx9_36/bytecodewriter.c   |  375 ++++++++++++++++++++++++++++++++++++++
 dlls/d3dx9_36/d3dx9_36_private.h |    9 +
 dlls/d3dx9_36/shader.c           |   23 ++-
 dlls/d3dx9_36/tests/asm.c        |   54 +++---
 5 files changed, 496 insertions(+), 27 deletions(-)

diff --git a/dlls/d3dx9_36/asmutils.c b/dlls/d3dx9_36/asmutils.c
index 50000a5..facb2af 100644
--- a/dlls/d3dx9_36/asmutils.c
+++ b/dlls/d3dx9_36/asmutils.c
@@ -27,6 +27,68 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(asmshader);
 
+/* bwriter -> d3d9 conversion functions */
+DWORD d3d9_swizzle(DWORD bwriter_swizzle) {
+    /* Currently a NOP, but this allows changing the internal definitions
+     * without side effects
+     */
+    DWORD ret = 0;
+
+    if((bwriter_swizzle & BWRITERVS_X_X) == BWRITERVS_X_X) ret |= D3DVS_X_X;
+    if((bwriter_swizzle & BWRITERVS_X_Y) == BWRITERVS_X_Y) ret |= D3DVS_X_Y;
+    if((bwriter_swizzle & BWRITERVS_X_Z) == BWRITERVS_X_Z) ret |= D3DVS_X_Z;
+    if((bwriter_swizzle & BWRITERVS_X_W) == BWRITERVS_X_W) ret |= D3DVS_X_W;
+
+    if((bwriter_swizzle & BWRITERVS_Y_X) == BWRITERVS_Y_X) ret |= D3DVS_Y_X;
+    if((bwriter_swizzle & BWRITERVS_Y_Y) == BWRITERVS_Y_Y) ret |= D3DVS_Y_Y;
+    if((bwriter_swizzle & BWRITERVS_Y_Z) == BWRITERVS_Y_Z) ret |= D3DVS_Y_Z;
+    if((bwriter_swizzle & BWRITERVS_Y_W) == BWRITERVS_Y_W) ret |= D3DVS_Y_W;
+
+    if((bwriter_swizzle & BWRITERVS_Z_X) == BWRITERVS_Z_X) ret |= D3DVS_Z_X;
+    if((bwriter_swizzle & BWRITERVS_Z_Y) == BWRITERVS_Z_Y) ret |= D3DVS_Z_Y;
+    if((bwriter_swizzle & BWRITERVS_Z_Z) == BWRITERVS_Z_Z) ret |= D3DVS_Z_Z;
+    if((bwriter_swizzle & BWRITERVS_Z_W) == BWRITERVS_Z_W) ret |= D3DVS_Z_W;
+
+    if((bwriter_swizzle & BWRITERVS_W_X) == BWRITERVS_W_X) ret |= D3DVS_W_X;
+    if((bwriter_swizzle & BWRITERVS_W_Y) == BWRITERVS_W_Y) ret |= D3DVS_W_Y;
+    if((bwriter_swizzle & BWRITERVS_W_Z) == BWRITERVS_W_Z) ret |= D3DVS_W_Z;
+    if((bwriter_swizzle & BWRITERVS_W_W) == BWRITERVS_W_W) ret |= D3DVS_W_W;
+
+    return ret;
+}
+
+DWORD d3d9_writemask(DWORD bwriter_writemask) {
+    DWORD ret = 0;
+
+    if(bwriter_writemask & BWRITERSP_WRITEMASK_0) ret |= D3DSP_WRITEMASK_0;
+    if(bwriter_writemask & BWRITERSP_WRITEMASK_1) ret |= D3DSP_WRITEMASK_1;
+    if(bwriter_writemask & BWRITERSP_WRITEMASK_2) ret |= D3DSP_WRITEMASK_2;
+    if(bwriter_writemask & BWRITERSP_WRITEMASK_3) ret |= D3DSP_WRITEMASK_3;
+
+    return ret;
+}
+
+DWORD d3d9_register(DWORD bwriter_register) {
+    if(bwriter_register == BWRITERSPR_TEMP)         return D3DSPR_TEMP;
+    if(bwriter_register == BWRITERSPR_CONST)        return D3DSPR_CONST;
+
+    FIXME("Unexpected BWRITERSPR %u\n", bwriter_register);
+    return -1;
+}
+
+DWORD d3d9_opcode(DWORD bwriter_opcode) {
+    switch(bwriter_opcode) {
+        case BWRITERSIO_MOV:         return D3DSIO_MOV;
+
+        case BWRITERSIO_COMMENT:     return D3DSIO_COMMENT;
+        case BWRITERSIO_END:         return D3DSIO_END;
+
+        default:
+            FIXME("Unhandled BWRITERSIO token %u\n", bwriter_opcode);
+            return -1;
+    }
+}
+
 static const char *get_regname(const struct shader_reg *reg, shader_type st) {
     switch(reg->type) {
         case BWRITERSPR_TEMP:
diff --git a/dlls/d3dx9_36/bytecodewriter.c b/dlls/d3dx9_36/bytecodewriter.c
index 30f7d1f..f97d2cc 100644
--- a/dlls/d3dx9_36/bytecodewriter.c
+++ b/dlls/d3dx9_36/bytecodewriter.c
@@ -104,6 +104,381 @@ BOOL add_instruction(struct bwriter_shader *shader, struct instruction *instr) {
     return TRUE;
 }
 
+/* shader bytecode buffer manipulation functions.
+ * allocate_buffer creates a new buffer structure, put_dword adds a new
+ * DWORD to the buffer. In the rare case of a memory allocation failure
+ * when trying to grow the buffer a flag is set in the buffer to mark it
+ * invalid. This avoids return value checking and passing in many places
+ */
+static struct bytecode_buffer *allocate_buffer(void) {
+    struct bytecode_buffer *ret;
+
+    ret = asm_alloc(sizeof(*ret));
+    if(!ret) return NULL;
+
+    ret->alloc_size = BYTECODEBUFFER_INITIAL_SIZE;
+    ret->data = asm_alloc(sizeof(DWORD) * ret->alloc_size);
+    if(!ret->data) {
+        asm_free(ret);
+        return NULL;
+    }
+    ret->state = S_OK;
+    return ret;
+}
+
+static void put_dword(struct bytecode_buffer *buffer, DWORD value) {
+    if(FAILED(buffer->state)) return;
+
+    if(buffer->alloc_size == buffer->size) {
+        DWORD *newarray;
+        buffer->alloc_size *= 2;
+        newarray = asm_realloc(buffer->data,
+                               sizeof(DWORD) * buffer->alloc_size);
+        if(!newarray) {
+            ERR("Failed to grow the buffer data memory\n");
+            buffer->state = E_OUTOFMEMORY;
+            return;
+        }
+        buffer->data = newarray;
+    }
+    buffer->data[buffer->size++] = value;
+}
+
+/******************************************************
+ * Implementation of the writer functions starts here *
+ ******************************************************/
+static void end(struct bc_writer *This, const struct bwriter_shader *shader, struct bytecode_buffer *buffer) {
+    put_dword(buffer, D3DSIO_END);
+}
+
+static void write_srcregs(struct bc_writer *This, const struct instruction *instr,
+                          struct bytecode_buffer *buffer){
+    unsigned int i;
+    if(instr->has_predicate){
+        This->funcs->srcreg(This, &instr->predicate, buffer);
+    }
+    for(i = 0; i < instr->num_srcs; i++){
+        This->funcs->srcreg(This, &instr->src[i], buffer);
+    }
+}
+
+/* The length of an instruction consists of the destination register (if any),
+ * the number of source registers, the number of address registers used for
+ * indirect addressing, and optionally the predicate register
+ */
+static DWORD instrlen(const struct instruction *instr, unsigned int srcs, unsigned int dsts) {
+    unsigned int i;
+    DWORD ret = srcs + dsts + (instr->has_predicate ? 1 : 0);
+
+    if(dsts){
+        if(instr->dst.rel_reg) ret++;
+    }
+    for(i = 0; i < srcs; i++) {
+        if(instr->src[i].rel_reg) ret++;
+    }
+    return ret;
+}
+
+static void instr_handler(struct bc_writer *This,
+                          const struct instruction *instr,
+                          struct bytecode_buffer *buffer) {
+    DWORD token = d3d9_opcode(instr->opcode);
+    TRACE("token: %x\n", token);
+
+    This->funcs->opcode(This, instr, token, buffer);
+    if(instr->has_dst) This->funcs->dstreg(This, &instr->dst, buffer, instr->shift, instr->dstmod);
+    write_srcregs(This, instr, buffer);
+}
+
+static void sm_2_opcode(struct bc_writer *This,
+                        const struct instruction *instr,
+                        DWORD token, struct bytecode_buffer *buffer) {
+    /* From sm 2 onwards instruction length is encoded in the opcode field */
+    int dsts = instr->has_dst ? 1 : 0;
+    token |= instrlen(instr, instr->num_srcs, dsts) << D3DSI_INSTLENGTH_SHIFT;
+    put_dword(buffer,token);
+}
+
+static void sm_3_header(struct bc_writer *This, const struct bwriter_shader *shader, struct bytecode_buffer *buffer) {
+    /* Declare the shader type and version */
+    put_dword(buffer, This->version);
+    return;
+}
+
+static void sm_3_srcreg(struct bc_writer *This,
+                        const struct shader_reg *reg,
+                        struct bytecode_buffer *buffer) {
+    DWORD token = (1 << 31); /* Bit 31 of registers is 1 */
+    DWORD d3d9reg;
+
+    d3d9reg = d3d9_register(reg->type);
+    token |= (d3d9reg << D3DSP_REGTYPE_SHIFT) & D3DSP_REGTYPE_MASK;
+    token |= (d3d9reg << D3DSP_REGTYPE_SHIFT2) & D3DSP_REGTYPE_MASK2;
+    token |= reg->regnum & D3DSP_REGNUM_MASK;
+
+    token |= d3d9_swizzle(reg->swizzle) & D3DVS_SWIZZLE_MASK;
+
+    put_dword(buffer, token);
+}
+
+static void sm_3_dstreg(struct bc_writer *This,
+                        const struct shader_reg *reg,
+                        struct bytecode_buffer *buffer,
+                        DWORD shift, DWORD mod) {
+    DWORD token = (1 << 31); /* Bit 31 of registers is 1 */
+    DWORD d3d9reg;
+
+    d3d9reg = d3d9_register(reg->type);
+    token |= (d3d9reg << D3DSP_REGTYPE_SHIFT) & D3DSP_REGTYPE_MASK;
+    token |= (d3d9reg << D3DSP_REGTYPE_SHIFT2) & D3DSP_REGTYPE_MASK2;
+    token |= reg->regnum & D3DSP_REGNUM_MASK; /* No shift */
+
+    token |= d3d9_writemask(reg->writemask);
+    put_dword(buffer, token);
+}
+
+static const struct instr_handler_table vs_3_handlers[] = {
+    {BWRITERSIO_MOV,            instr_handler},
+    {BWRITERSIO_END,            NULL},
+};
+
+static const struct bytecode_backend vs_3_backend = {
+    sm_3_header,
+    end,
+    sm_3_srcreg,
+    sm_3_dstreg,
+    sm_2_opcode,
+    vs_3_handlers
+};
+
+static void init_vs30_dx9_writer(struct bc_writer *writer) {
+    TRACE("Creating DirectX9 vertex shader 3.0 writer\n");
+    writer->funcs = &vs_3_backend;
+}
+
+static struct bc_writer *create_writer(DWORD version, DWORD dxversion) {
+    struct bc_writer *ret = asm_alloc(sizeof(*ret));
+
+    if(!ret) {
+        WARN("Failed to allocate a bytecode writer instance\n");
+        return NULL;
+    }
+
+    switch(version) {
+        case BWRITERVS_VERSION(1, 0):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for vertex shader 1.0 requested: %u\n", dxversion);
+                goto fail;
+            }
+            /* TODO: Set the appropriate writer backend */
+            break;
+        case BWRITERVS_VERSION(1, 1):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for vertex shader 1.1 requested: %u\n", dxversion);
+                goto fail;
+            }
+            /* TODO: Set the appropriate writer backend */
+            break;
+        case BWRITERVS_VERSION(2, 0):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for vertex shader 2.0 requested: %u\n", dxversion);
+                goto fail;
+            }
+            /* TODO: Set the appropriate writer backend */
+            break;
+        case BWRITERVS_VERSION(2, 1):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for vertex shader 2.x requested: %u\n", dxversion);
+                goto fail;
+            }
+            /* TODO: Set the appropriate writer backend */
+            break;
+        case BWRITERVS_VERSION(3, 0):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for vertex shader 3.0 requested: %u\n", dxversion);
+                goto fail;
+            }
+            init_vs30_dx9_writer(ret);
+            break;
+
+        case BWRITERPS_VERSION(1, 0):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for pixel shader 1.0 requested: %u\n", dxversion);
+                goto fail;
+            }
+            /* TODO: Set the appropriate writer backend */
+            break;
+        case BWRITERPS_VERSION(1, 1):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for pixel shader 1.1 requested: %u\n", dxversion);
+                goto fail;
+            }
+            /* TODO: Set the appropriate writer backend */
+            break;
+        case BWRITERPS_VERSION(1, 2):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for pixel shader 1.2 requested: %u\n", dxversion);
+                goto fail;
+            }
+            /* TODO: Set the appropriate writer backend */
+            break;
+        case BWRITERPS_VERSION(1, 3):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for pixel shader 1.3 requested: %u\n", dxversion);
+                goto fail;
+            }
+            /* TODO: Set the appropriate writer backend */
+            break;
+        case BWRITERPS_VERSION(1, 4):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for pixel shader 1.4 requested: %u\n", dxversion);
+                goto fail;
+            }
+            /* TODO: Set the appropriate writer backend */
+            break;
+
+        case BWRITERPS_VERSION(2, 0):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for pixel shader 2.0 requested: %u\n", dxversion);
+                goto fail;
+            }
+            /* TODO: Set the appropriate writer backend */
+            break;
+
+        case BWRITERPS_VERSION(2, 1):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for pixel shader 2.x requested: %u\n", dxversion);
+                goto fail;
+            }
+            /* TODO: Set the appropriate writer backend */
+            break;
+
+        case BWRITERPS_VERSION(3, 0):
+            if(dxversion != 9) {
+                WARN("Unsupported dxversion for pixel shader 3.0 requested: %u\n", dxversion);
+                goto fail;
+            }
+            /* TODO: Set the appropriate writer backend */
+            break;
+
+        default:
+            WARN("Unexpected shader version requested: %08x\n", version);
+            goto fail;
+    }
+    ret->version = version;
+    return ret;
+
+fail:
+    asm_free(ret);
+    return NULL;
+}
+
+static HRESULT call_instr_handler(struct bc_writer *writer,
+                                  const struct instruction *instr,
+                                  struct bytecode_buffer *buffer) {
+    DWORD i=0;
+
+    while(writer->funcs->instructions[i].opcode != BWRITERSIO_END) {
+        if(instr->opcode == writer->funcs->instructions[i].opcode) {
+            if(!writer->funcs->instructions[i].func) {
+                WARN("Opcode %u not supported by this profile\n", instr->opcode);
+                return E_INVALIDARG;
+            }
+            writer->funcs->instructions[i].func(writer, instr, buffer);
+            return S_OK;
+        }
+        i++;
+    }
+
+    FIXME("Unhandled instruction %u\n", instr->opcode);
+    return E_INVALIDARG;
+}
+
+/* SlWriteBytecode (wineshader.@)
+ *
+ * Writes shader version specific bytecode from the shader passed in.
+ * The returned bytecode can be passed to the Direct3D runtime like
+ * IDirect3DDevice9::Create*Shader.
+ *
+ * Parameters:
+ *  shader: Shader to translate into bytecode
+ *  version: Shader version to generate(d3d version token)
+ *  dxversion: DirectX version the code targets
+ *  result: the resulting shader bytecode
+ *
+ * Return values:
+ *  S_OK on success
+ */
+DWORD SlWriteBytecode(const struct bwriter_shader *shader, int dxversion, DWORD **result) {
+    struct bc_writer *writer;
+    struct bytecode_buffer *buffer = NULL;
+    HRESULT hr;
+    unsigned int i;
+
+    if(!shader){
+        ERR("NULL shader structure, aborting\n");
+        return E_FAIL;
+    }
+    writer = create_writer(shader->version, dxversion);
+    *result = NULL;
+
+    if(!writer) {
+        WARN("Could not create a bytecode writer instance. Either unsupported version\n");
+        WARN("or out of memory\n");
+        hr = E_FAIL;
+        goto error;
+    }
+
+    buffer = allocate_buffer();
+    if(!buffer) {
+        WARN("Failed to allocate a buffer for the shader bytecode\n");
+        hr = E_FAIL;
+        goto error;
+    }
+
+    writer->funcs->header(writer, shader, buffer);
+    if(FAILED(writer->state)) {
+        hr = writer->state;
+        goto error;
+    }
+
+    for(i = 0; i < shader->num_instrs; i++) {
+        hr = call_instr_handler(writer, shader->instr[i], buffer);
+        if(FAILED(hr)) {
+            goto error;
+        }
+    }
+
+    if(FAILED(writer->state)) {
+        hr = writer->state;
+        goto error;
+    }
+
+    writer->funcs->end(writer, shader, buffer);
+
+    if(FAILED(buffer->state)) {
+        hr = buffer->state;
+        goto error;
+    }
+
+    /* Cut off unneeded memory from the result buffer */
+    *result = asm_realloc(buffer->data,
+                         sizeof(DWORD) * buffer->size);
+    if(!*result) {
+        *result = buffer->data;
+    }
+    buffer->data = NULL;
+    hr = S_OK;
+
+error:
+    if(buffer) {
+        asm_free(buffer->data);
+        asm_free(buffer);
+    }
+    asm_free(writer);
+    return hr;
+}
+
 void SlDeleteShader(struct bwriter_shader *shader) {
     unsigned int i, j;
 
diff --git a/dlls/d3dx9_36/d3dx9_36_private.h b/dlls/d3dx9_36/d3dx9_36_private.h
index 90aa747..275b153 100644
--- a/dlls/d3dx9_36/d3dx9_36_private.h
+++ b/dlls/d3dx9_36/d3dx9_36_private.h
@@ -160,6 +160,8 @@ struct instruction {
     struct shader_reg       dst;
     struct shader_reg       *src;
     unsigned int            num_srcs; /* For freeing the rel_regs */
+    BOOL                    has_predicate;
+    struct shader_reg       predicate;
 };
 
 struct declaration {
@@ -342,6 +344,12 @@ const char *debug_print_dstreg(const struct shader_reg *reg, shader_type st);
 const char *debug_print_srcreg(const struct shader_reg *reg, shader_type st);
 const char *debug_print_opcode(DWORD opcode);
 
+/* Utilities for internal->d3d constant mapping */
+DWORD d3d9_swizzle(DWORD bwriter_swizzle);
+DWORD d3d9_writemask(DWORD bwriter_writemask);
+DWORD d3d9_register(DWORD bwriter_register);
+DWORD d3d9_opcode(DWORD bwriter_opcode);
+
 /*
   Enumerations and defines used in the bytecode writer
   intermediate representation
@@ -400,6 +408,7 @@ typedef enum _BWRITERSHADER_PARAM_SRCMOD_TYPE {
 #define BWRITERVS_NOSWIZZLE (BWRITERVS_X_X | BWRITERVS_Y_Y | BWRITERVS_Z_Z | BWRITERVS_W_W)
 
 struct bwriter_shader *SlAssembleShader(const char *text, char **messages);
+DWORD SlWriteBytecode(const struct bwriter_shader *shader, int dxversion, DWORD **result);
 void SlDeleteShader(struct bwriter_shader *shader);
 
 #endif /* __WINE_D3DX9_36_PRIVATE_H */
diff --git a/dlls/d3dx9_36/shader.c b/dlls/d3dx9_36/shader.c
index bb9353f..3aeaf78 100644
--- a/dlls/d3dx9_36/shader.c
+++ b/dlls/d3dx9_36/shader.c
@@ -388,6 +388,7 @@ HRESULT assemble_shader(const char *preprocShader, const char *preprocMessages,
     struct bwriter_shader *shader;
     char *messages = NULL;
     HRESULT hr;
+    DWORD *res;
     LPD3DXBUFFER buffer;
     int size;
     char *pos;
@@ -439,9 +440,27 @@ HRESULT assemble_shader(const char *preprocShader, const char *preprocMessages,
         return D3DXERR_INVALIDDATA;
     }
 
-    /* TODO: generate bytecode from the shader */
+    hr = SlWriteBytecode(shader, 9, &res);
     SlDeleteShader(shader);
-    return D3DXERR_INVALIDDATA;
+    if(FAILED(hr))
+    {
+        ERR("SlWriteBytecode failed with 0x%08x\n", hr);
+        return D3DXERR_INVALIDDATA;
+    }
+
+    size = HeapSize(GetProcessHeap(), 0, res);
+    hr = D3DXCreateBuffer(size, &buffer);
+    if(FAILED(hr))
+    {
+        HeapFree(GetProcessHeap(), 0, res);
+        return hr;
+    }
+    CopyMemory(ID3DXBuffer_GetBufferPointer(buffer), res, size);
+    *ppShader = buffer;
+
+    HeapFree(GetProcessHeap(), 0, res);
+
+    return D3D_OK;
 }
 
 HRESULT WINAPI D3DXAssembleShader(LPCSTR data,
diff --git a/dlls/d3dx9_36/tests/asm.c b/dlls/d3dx9_36/tests/asm.c
index 6622390..de29e45 100644
--- a/dlls/d3dx9_36/tests/asm.c
+++ b/dlls/d3dx9_36/tests/asm.c
@@ -1008,52 +1008,56 @@ static void ps_2_x_test(void) {
 }
 
 static void vs_3_0_test(void) {
+    /* FIXME: Some tests are temporarily commented out, because the
+       current implementation doesn't support the entire vs_3_0 syntax
+       and it is not trivial to remove todo_wine only from
+       a subset of the tests here */
     struct shader_test tests[] = {
         {   /* shader 0 */
             "vs_3_0\n"
             "mov r0, c0\n",
             {0xfffe0300, 0x02000001, 0x800f0000, 0xa0e40000, 0x0000ffff}
         },
-        {   /* shader 1 */
-            "vs_3_0\n"
+/*      {*/ /* shader 1 */
+/*          "vs_3_0\n"
             "dcl_2d s0\n",
             {0xfffe0300, 0x0200001f, 0x90000000, 0xa00f0800, 0x0000ffff}
-        },
-        {   /* shader 2 */
-            "vs_3_0\n"
+        },*/
+/*      {*/ /* shader 2 */
+/*          "vs_3_0\n"
             "dcl_position o0\n",
             {0xfffe0300, 0x0200001f, 0x80000000, 0xe00f0000, 0x0000ffff}
-        },
-        {   /* shader 3 */
-            "vs_3_0\n"
+        },*/
+/*      {*/ /* shader 3 */
+/*          "vs_3_0\n"
             "dcl_texcoord12 o11\n",
             {0xfffe0300, 0x0200001f, 0x800c0005, 0xe00f000b, 0x0000ffff}
-        },
-        {   /* shader 4 */
-            "vs_3_0\n"
+        },*/
+/*      {*/ /* shader 4 */
+/*          "vs_3_0\n"
             "texldl r0, v0, s0\n",
             {0xfffe0300, 0x0300005f, 0x800f0000, 0x90e40000, 0xa0e40800, 0x0000ffff}
-        },
-        {   /* shader 5 */
-            "vs_3_0\n"
+        },*/
+/*      {*/ /* shader 5 */
+/*          "vs_3_0\n"
             "mov r0, c0[aL]\n",
             {0xfffe0300, 0x03000001, 0x800f0000, 0xa0e42000, 0xf0e40800, 0x0000ffff}
-        },
-        {   /* shader 6 */
-            "vs_3_0\n"
+        },*/
+/*      {*/ /* shader 6 */
+/*          "vs_3_0\n"
             "mov o[ a0.x + 12 ], r0\n",
             {0xfffe0300, 0x03000001, 0xe00f200c, 0xb0000000, 0x80e40000, 0x0000ffff}
-        },
-        {   /* shader 7 */
-            "vs_3_0\n"
+        },*/
+/*      {*/ /* shader 7 */
+/*          "vs_3_0\n"
             "add_sat r0, r0, r1\n",
             {0xfffe0300, 0x03000002, 0x801f0000, 0x80e40000, 0x80e40001, 0x0000ffff}
-        },
-        {   /* shader 8 */
-            "vs_3_0\n"
+        },*/
+/*      {*/ /* shader 8 */
+/*          "vs_3_0\n"
             "mov r2, r1_abs\n",
             {0xfffe0300, 0x02000001, 0x800f0002, 0x8be40001, 0x0000ffff}
-        },
+        },*/
     };
 
     exec_tests("vs_3_0", tests, sizeof(tests) / sizeof(tests[0]));
@@ -1404,7 +1408,7 @@ START_TEST(asm)
     todo_wine vs_2_x_test();
     todo_wine ps_2_0_test();
     todo_wine ps_2_x_test();
-    todo_wine vs_3_0_test();
+    vs_3_0_test();
     todo_wine ps_3_0_test();
 
     failure_test();
-- 
1.6.4.4


More information about the wine-patches mailing list