[PATCH vkd3d 1/5] vkd3d-shader: Mark all declared non-static global variables as HLSL_STORAGE_UNIFORM.

[Zebediah Figura]

Fixes: 549be35c0aff6aa78f1dc9a08df89ce8de16db2c
Signed-off-by: Zebediah Figura 
---
 libs/vkd3d-shader/hlsl.y         | 6 ++++++
 libs/vkd3d-shader/hlsl_codegen.c | 2 +-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/libs/vkd3d-shader/hlsl.y b/libs/vkd3d-shader/hlsl.y
index 2c9fe551..bcb1c207 100644
--- a/libs/vkd3d-shader/hlsl.y
+++ b/libs/vkd3d-shader/hlsl.y
@@ -1427,6 +1427,12 @@ static struct list *declare_vars(struct hlsl_ctx *ctx, struct hlsl_type *basic_t
                 hlsl_error(ctx, var->loc, VKD3D_SHADER_ERROR_HLSL_INVALID_MODIFIER,
                         "Variable '%s' is declared as both "uniform" and "static".", var->name);

+            /* Mark it as uniform. We need to do this here since synthetic
+             * variables also get put in the global scope, but shouldn't be
+             * considered uniforms, and we have no way of telling otherwise. */
+            if (!(modifiers & HLSL_STORAGE_STATIC))
+                var->modifiers |= HLSL_STORAGE_UNIFORM;
+
             if ((func = hlsl_get_func_decl(ctx, var->name)))
             {
                 hlsl_error(ctx, var->loc, VKD3D_SHADER_ERROR_HLSL_REDEFINED,
diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c
index 0dfbfb9f..716824ae 100644
--- a/libs/vkd3d-shader/hlsl_codegen.c
+++ b/libs/vkd3d-shader/hlsl_codegen.c
@@ -1757,7 +1757,7 @@ int hlsl_emit_dxbc(struct hlsl_ctx *ctx, struct hlsl_ir_function_decl *entry_fun
     {
         if (var->data_type->type == HLSL_CLASS_OBJECT)
             list_add_tail(&ctx->extern_vars, &var->extern_entry);
-        else if (!(var->modifiers & HLSL_STORAGE_STATIC))
+        else if (var->modifiers & HLSL_STORAGE_UNIFORM)
             prepend_uniform_copy(ctx, entry_func->body, var);
     }

[PATCH vkd3d 2/5] vkd3d-shader: Trace SM1 predefined registers.

[Zebediah Figura]

Signed-off-by: Zebediah Figura 
---
 libs/vkd3d-shader/hlsl_codegen.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c
index 716824ae..b3d7d2c2 100644
--- a/libs/vkd3d-shader/hlsl_codegen.c
+++ b/libs/vkd3d-shader/hlsl_codegen.c
@@ -1073,7 +1073,13 @@ static void allocate_semantic_register(struct hlsl_ctx *ctx, struct hlsl_ir_var
             return;
         }

-        if (!sm1_register_from_semantic(ctx, &var->semantic, output, &type, &reg))
+        if (sm1_register_from_semantic(ctx, &var->semantic, output, &type, &reg))
+        {
+            TRACE("%s %s semantic %s[%u] matches predefined register %#x[%u].\n",
+                    ctx->profile->type == VKD3D_SHADER_TYPE_PIXEL ? "Pixel" : "Vertex", output ? "output" : "input",
+                    var->semantic.name, var->semantic.index, type, reg);
+        }
+        else
         {
             var->reg.allocated = true;
             var->reg.id = (*counter)++;

[PATCH vkd3d 2/5] vkd3d-shader: Trace SM1 predefined registers.

[Matteo Bruni]

Signed-off-by: Matteo Bruni

[PATCH vkd3d 2/5] vkd3d-shader: Trace SM1 predefined registers.

[Henri Verbeet]

Signed-off-by: Henri Verbeet

[PATCH vkd3d 3/5] vkd3d-shader: Introduce write_sm1_{src, dst}_register() helpers.

[Zebediah Figura]

Signed-off-by: Zebediah Figura 
---
 libs/vkd3d-shader/hlsl_codegen.c | 64 ++++++++++++++++----------------
 1 file changed, 33 insertions(+), 31 deletions(-)

diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c
index b3d7d2c2..7dd919b8 100644
--- a/libs/vkd3d-shader/hlsl_codegen.c
+++ b/libs/vkd3d-shader/hlsl_codegen.c
@@ -1523,23 +1523,11 @@ static uint32_t sm1_encode_register_type(D3DSHADER_PARAM_REGISTER_TYPE type)
             | ((type << D3DSP_REGTYPE_SHIFT2) & D3DSP_REGTYPE_MASK2);
 }

-static uint32_t sm1_encode_dst(D3DSHADER_PARAM_REGISTER_TYPE type,
-        D3DSHADER_PARAM_DSTMOD_TYPE modifier, unsigned int writemask, unsigned int reg)
-{
-    return (1u << 31) | sm1_encode_register_type(type) | modifier | (writemask << 16) | reg;
-}
-
-static uint32_t sm1_encode_src(D3DSHADER_PARAM_REGISTER_TYPE type,
-        D3DSHADER_PARAM_SRCMOD_TYPE modifier, unsigned int swizzle, uint32_t reg)
-{
-    return (1u << 31) | sm1_encode_register_type(type) | modifier | (swizzle << 16) | reg;
-}
-
 struct sm1_instruction
 {
     D3DSHADER_INSTRUCTION_OPCODE_TYPE opcode;

-    struct
+    struct sm1_dst_register
     {
         D3DSHADER_PARAM_REGISTER_TYPE type;
         D3DSHADER_PARAM_DSTMOD_TYPE mod;
@@ -1547,7 +1535,7 @@ struct sm1_instruction
         uint32_t reg;
     } dst;

-    struct
+    struct sm1_src_register
     {
         D3DSHADER_PARAM_REGISTER_TYPE type;
         D3DSHADER_PARAM_SRCMOD_TYPE mod;
@@ -1559,6 +1547,20 @@ struct sm1_instruction
     unsigned int has_dst;
 };

+static void write_sm1_dst_register(struct bytecode_buffer *buffer, const struct sm1_dst_register *reg)
+{
+    assert(reg->writemask);
+    put_dword(buffer, (1u << 31) | sm1_encode_register_type(reg->type) | reg->mod | (reg->writemask << 16) | reg->reg);
+}
+
+static void write_sm1_src_register(struct bytecode_buffer *buffer,
+        const struct sm1_src_register *reg, unsigned int dst_writemask)
+{
+    unsigned int swizzle = map_swizzle(reg->swizzle, dst_writemask);
+
+    put_dword(buffer, (1u << 31) | sm1_encode_register_type(reg->type) | reg->mod | (swizzle << 16) | reg->reg);
+}
+
 static void write_sm1_instruction(struct hlsl_ctx *ctx, struct bytecode_buffer *buffer,
         const struct sm1_instruction *instr)
 {
@@ -1570,14 +1572,10 @@ static void write_sm1_instruction(struct hlsl_ctx *ctx, struct bytecode_buffer *
     put_dword(buffer, token);

if (instr->has_dst)
-    {
-        assert(instr->dst.writemask);
-        put_dword(buffer, sm1_encode_dst(instr->dst.type, instr->dst.mod, instr->dst.writemask, instr->dst.reg));
-    }
+        write_sm1_dst_register(buffer, &instr->dst);

for (i = 0; i < instr->src_count; ++i)
-        put_dword(buffer, sm1_encode_src(instr->srcs[i].type, instr->srcs[i].mod,
-                map_swizzle(instr->srcs[i].swizzle, instr->dst.writemask), instr->srcs[i].reg));
+        write_sm1_src_register(buffer, &instr->srcs[i], instr->dst.writemask);
 };

static void write_sm1_constant_defs(struct hlsl_ctx *ctx, struct bytecode_buffer *buffer)
@@ -1587,16 +1585,18 @@ static void write_sm1_constant_defs(struct hlsl_ctx *ctx, struct bytecode_buffer
     for (i = 0; i < ctx->constant_defs.count; ++i)
     {
         uint32_t token = D3DSIO_DEF;
+        const struct sm1_dst_register reg =
+        {
+            .type = D3DSPR_CONST,
+            .writemask = VKD3DSP_WRITEMASK_ALL,
+            .reg = i,
+        };

if (ctx->profile->major_version > 1)
             token |= 5 << D3DSI_INSTLENGTH_SHIFT;
         put_dword(buffer, token);

-        token = (1u << 31);
-        token |= sm1_encode_register_type(D3DSPR_CONST);
-        token |= D3DSP_WRITEMASK_ALL;
-        token |= i;
-        put_dword(buffer, token);
+        write_sm1_dst_register(buffer, &reg);
         for (x = 0; x < 4; ++x)
             put_float(buffer, ctx->constant_defs.values[i].f[x]);
     }
@@ -1605,12 +1605,12 @@ static void write_sm1_constant_defs(struct hlsl_ctx *ctx, struct bytecode_buffer
 static void write_sm1_semantic_dcl(struct hlsl_ctx *ctx, struct bytecode_buffer *buffer,
         const struct hlsl_ir_var *var, bool output)
 {
-    D3DSHADER_PARAM_REGISTER_TYPE type;
-    uint32_t token, usage_idx, reg_idx;
+    struct sm1_dst_register reg = {0};
+    uint32_t token, usage_idx;
     D3DDECLUSAGE usage;
     bool ret;

-    if (sm1_register_from_semantic(ctx, &var->semantic, output, &type, &reg_idx))
+    if (sm1_register_from_semantic(ctx, &var->semantic, output, &reg.type, &reg.reg))
     {
         usage = 0;
         usage_idx = 0;
@@ -1619,8 +1619,8 @@ static void write_sm1_semantic_dcl(struct hlsl_ctx *ctx, struct bytecode_buffer
     {
         ret = sm1_usage_from_semantic(&var->semantic, &usage, &usage_idx);
         assert(ret);
-        type = output ? D3DSPR_OUTPUT : D3DSPR_INPUT;
-        reg_idx = var->reg.id;
+        reg.type = output ? D3DSPR_OUTPUT : D3DSPR_INPUT;
+        reg.reg = var->reg.id;
     }

token = D3DSIO_DCL;
@@ -1632,7 +1632,9 @@ static void write_sm1_semantic_dcl(struct hlsl_ctx *ctx, struct bytecode_buffer
     token |= usage << D3DSP_DCL_USAGE_SHIFT;
     token |= usage_idx << D3DSP_DCL_USAGEINDEX_SHIFT;
     put_dword(buffer, token);
-    put_dword(buffer, sm1_encode_dst(type, D3DSPDM_NONE, (1 << var->data_type->dimx) - 1, reg_idx));
+
+    reg.writemask = (1 << var->data_type->dimx) - 1;
+    write_sm1_dst_register(buffer, &reg);
 }

static void write_sm1_semantic_dcls(struct hlsl_ctx *ctx, struct bytecode_buffer *buffer)

[PATCH vkd3d 3/5] vkd3d-shader: Introduce write_sm1_{src, dst}_register() helpers.

[Matteo Bruni]

Signed-off-by: Matteo Bruni

[PATCH vkd3d 3/5] vkd3d-shader: Introduce write_sm1_{src, dst}_register() helpers.

[Henri Verbeet]

Signed-off-by: Henri Verbeet

[PATCH vkd3d 4/5] vkd3d-shader: Sanity-check the offset data type in hlsl_reg_from_deref().

[Zebediah Figura]

Signed-off-by: Zebediah Figura 
---
 libs/vkd3d-shader/hlsl_codegen.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c
index 7dd919b8..10bf80b6 100644
--- a/libs/vkd3d-shader/hlsl_codegen.c
+++ b/libs/vkd3d-shader/hlsl_codegen.c
@@ -1171,6 +1171,11 @@ static struct hlsl_reg hlsl_reg_from_deref(const struct hlsl_deref *deref, const
     struct hlsl_reg ret = {0};
     unsigned int offset = 0;

+    /* We should always have generated a cast to UINT. */
+    if (offset_node)
+        assert(offset_node->data_type->type == HLSL_CLASS_SCALAR
+                && offset_node->data_type->base_type == HLSL_TYPE_UINT);
+
     if (offset_node && offset_node->type != HLSL_IR_CONSTANT)
     {
         FIXME("Dereference with non-constant offset of type %s.\n", hlsl_node_type_to_string(offset_node->type));

[PATCH vkd3d 4/5] vkd3d-shader: Sanity-check the offset data type in hlsl_reg_from_deref().

[Matteo Bruni]

Signed-off-by: Matteo Bruni

[PATCH vkd3d 4/5] vkd3d-shader: Sanity-check the offset data type in hlsl_reg_from_deref().

[Henri Verbeet]

Signed-off-by: Henri Verbeet

[PATCH vkd3d 5/5] vkd3d-shader: Write SM1 load instructions.

[Zebediah Figura]

Signed-off-by: Zebediah Figura 
---
 libs/vkd3d-shader/hlsl_codegen.c | 46 ++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/libs/vkd3d-shader/hlsl_codegen.c b/libs/vkd3d-shader/hlsl_codegen.c
index 10bf80b6..05aea217 100644
--- a/libs/vkd3d-shader/hlsl_codegen.c
+++ b/libs/vkd3d-shader/hlsl_codegen.c
@@ -1663,6 +1663,48 @@ static void write_sm1_semantic_dcls(struct hlsl_ctx *ctx, struct bytecode_buffer
     }
 }

+static void write_sm1_load(struct hlsl_ctx *ctx, struct bytecode_buffer *buffer, const struct hlsl_ir_node *instr)
+{
+    const struct hlsl_ir_load *load = hlsl_ir_load(instr);
+    const struct hlsl_reg reg = hlsl_reg_from_deref(&load->src, instr->data_type);
+    struct sm1_instruction sm1_instr =
+    {
+        .opcode = D3DSIO_MOV,
+
+        .dst.type = D3DSPR_TEMP,
+        .dst.reg = instr->reg.id,
+        .dst.writemask = instr->reg.writemask,
+        .has_dst = 1,
+
+        .srcs[0].type = D3DSPR_TEMP,
+        .srcs[0].reg = reg.id,
+        .srcs[0].swizzle = swizzle_from_writemask(reg.writemask),
+        .src_count = 1,
+    };
+
+    assert(instr->reg.allocated);
+
+    if (load->src.var->is_uniform)
+    {
+        assert(reg.allocated);
+        sm1_instr.srcs[0].type = D3DSPR_CONST;
+    }
+    else if (load->src.var->is_input_semantic)
+    {
+        if (!sm1_register_from_semantic(ctx, &load->src.var->semantic,
+                false, &sm1_instr.srcs[0].type, &sm1_instr.srcs[0].reg))
+        {
+            assert(reg.allocated);
+            sm1_instr.srcs[0].type = D3DSPR_INPUT;
+            sm1_instr.srcs[0].reg = reg.id;
+        }
+        else
+            sm1_instr.srcs[0].swizzle = swizzle_from_writemask((1 << load->src.var->data_type->dimx) - 1);
+    }
+
+    write_sm1_instruction(ctx, buffer, &sm1_instr);
+}
+
 static void write_sm1_store(struct hlsl_ctx *ctx, struct bytecode_buffer *buffer, const struct hlsl_ir_node *instr)
 {
     const struct hlsl_ir_store *store = hlsl_ir_store(instr);
@@ -1726,6 +1768,10 @@ static void write_sm1_instructions(struct hlsl_ctx *ctx, struct bytecode_buffer

switch (instr->type)
         {
+            case HLSL_IR_LOAD:
+                write_sm1_load(ctx, buffer, instr);
+                break;
+
             case HLSL_IR_STORE:
                 write_sm1_store(ctx, buffer, instr);
                 break;

[PATCH vkd3d 5/5] vkd3d-shader: Write SM1 load instructions.

[Matteo Bruni]

Signed-off-by: Matteo Bruni

[PATCH vkd3d 5/5] vkd3d-shader: Write SM1 load instructions.

[Henri Verbeet]

Signed-off-by: Henri Verbeet

[Matteo Bruni]

Signed-off-by: Matteo Bruni

[Henri Verbeet]

Signed-off-by: Henri Verbeet