wine/vkd3d
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/vkd3d.git synced 2024-11-21 16:46:41 -08:00
Code Issues Packages Projects Releases Wiki Activity
6,227 Commits 2 Branches 17 Tags 18 MiB
466c8bfbb7
Commit Graph

3282 Commits

Author SHA1 Message Date
Nikolay Sivov
30cc6ceb44 vkd3d-shader/fx: Add support for writing shared object descriptions for fx_4_x. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-03-12 22:14:41 +01:00
Nikolay Sivov
13227f3852 vkd3d-shader: Add an option to enable child effects compilation. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-03-12 22:14:41 +01:00
Nikolay Sivov
7f1fdd447c vkd3d-shader/fx: Add initial support for writing uninitialized vertex/pixel shader objects. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-03-12 22:14:40 +01:00
Henri Verbeet
038764985a vkd3d-shader/glsl: Use location information from the current instruction. 2024-03-11 22:10:21 +01:00
Conor McCarthy
4f0e5b9069 vkd3d-shader/dxil: Support 16-bit types. 2024-03-11 22:10:06 +01:00
Conor McCarthy
066ea75945 vkd3d-shader/spirv: Introduce HALF and UINT16 types for minimum precision. 
Minimum precision types must always be implemented as 32-bit to match how
reduced precision works in SPIR-V.
 2024-03-11 22:10:05 +01:00
Conor McCarthy
58123c2e10 vkd3d-shader/spirv: Introduce a data_type_is_floating_point() helper function. 2024-03-11 22:10:03 +01:00
Nikolay Sivov
25d353db91 vkd3d-shader/d3dbc: Do not write semantic declarations for unused variables. 
Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=55829
Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=56402
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-03-11 22:09:55 +01:00
Zebediah Figura
ad495970e0 vkd3d-shader/spirv: Implement SLT and SGE. 2024-03-11 22:09:48 +01:00
Zebediah Figura
27196d8b0f vkd3d-shader/spirv: Implement CMP. 2024-03-11 22:09:44 +01:00
Francisco Casas
cfac67ccc2 vkd3d-shader/hlsl: Cast slt before multiplying on ternary operator. 
Otherwise we may get a failing
    "hlsl_types_are_equal(arg1->data_type, arg2->data_type)"
assertion on hlsl_new_binary_expr() when creating the MUL.

This happens in the test introducing in the following patch:

    int a, b, c;

    void main(out float4 res : COLOR1, in float4 pos : position, out float4 out_pos : sv_position)
    {
        out_pos = pos;

        res = a ? b/1000.0 : c/1000.0;
    }
 2024-03-11 22:09:42 +01:00
Giovanni Mascellani
1690b0b554 vkd3d-shader: Remove the bytecode fields from vkd3d_shader_desc. 2024-03-11 22:09:32 +01:00
Giovanni Mascellani
204c8afb9c vkd3d-shader/dxbc: Remove flag is_dxil. 
The full shader profile is already available in vsir_program.
 2024-03-11 22:09:31 +01:00
Giovanni Mascellani
470d83a9da vkd3d-shader: Move shader signatures to vsir_program. 2024-03-11 22:09:31 +01:00
Giovanni Mascellani
56dc0c9842 vkd3d-shader/dxbc: Decouple vkd3d_shader_desc from DXBC parsing. 2024-03-11 22:09:30 +01:00
Giovanni Mascellani
5204b92fa0 vkd3d-shader/tpf: Remove a useless parameter to shader_sm4_init(). 2024-03-11 22:09:28 +01:00
Conor McCarthy
7b4b0143bd vkd3d-shader/dxil: Implement DX intrinsic TextureGatherCmp. 2024-03-11 22:09:20 +01:00
Conor McCarthy
5a6fd010ac vkd3d-shader/dxil: Implement DX intrinsic TextureGather. 2024-03-11 22:09:18 +01:00
Giovanni Mascellani
75bc68962d vkd3d-shader/dxbc: Add flag to ignore the DXBC checksum. 2024-03-11 22:08:55 +01:00
Giovanni Mascellani
23259263cf vkd3d-shader/d3d-asm: Only emit signatures for SM4-6. 2024-03-08 23:36:44 +01:00
Henri Verbeet
1fc55d80cd vkd3d-shader: Enable GLSL target support when VKD3D_SHADER_UNSUPPORTED_GLSL is defined. 2024-03-08 23:36:40 +01:00
Evan Tang
4553b2a0dc vkd3d-shader/spirv: Implement support for rasteriser-ordered views. 
Using SPV_EXT_fragment_shader_interlock.
 2024-03-08 23:36:35 +01:00
Giovanni Mascellani
21f76257b0 vkd3d-shader/d3d-asm: Print labels in red. 
They are substantially different from any other register type, so
it makes sense to have them stand out. Also, they help segmenting
visually the code into blocks, because labels are usually found
either at the beginning or at the end of a block.
 2024-03-08 23:36:25 +01:00
Conor McCarthy
e65055b435 vkd3d-shader/spirv: Handle the ORD and UNO instructions. 2024-03-08 23:36:14 +01:00
Conor McCarthy
f212aad0ff vkd3d-shader/dxil: Support FCMP_ORD and FCMP_UNO for CMP2. 2024-03-08 23:36:13 +01:00
Giovanni Mascellani
172e7edf2d vkd3d-shader: Refactor common code for vkd3d_shader_compile(). 2024-03-08 23:35:54 +01:00
Giovanni Mascellani
0e5d6a97cc vkd3d-shader: Refactor common code for vkd3d_shader_scan(). 2024-03-08 23:35:54 +01:00
Giovanni Mascellani
bbd37a76fc vkd3d-shader: Treat the HLSL case specially in vkd3d_shader_compile(). 2024-03-08 23:35:54 +01:00
Giovanni Mascellani
3a1c32acd4 vkd3d-shader: Treat the HLSL case specially in vkd3d_shader_scan(). 
The other cases are similar and common code can be refactored.
Ideally the HLSL parser will eventually fit the same model, but that
will require more extensive work.
 2024-03-08 23:35:53 +01:00
Giovanni Mascellani
b940d79aa8 vkd3d-shader/ir: Keep loops contiguous in the topological sort. 2024-03-08 23:35:48 +01:00
Giovanni Mascellani
cf9a023566 vkd3d-shader/ir: Dump the topological order of the control flow graph. 2024-03-08 23:35:47 +01:00
Giovanni Mascellani
ed40646c8a vkd3d-shader/ir: Topologically sort the control flow graph. 2024-03-08 23:35:46 +01:00
Giovanni Mascellani
880d781b57 vkd3d-shader/ir: Allow adding to a block list without checking for duplicates. 2024-03-08 23:35:45 +01:00
Nikolay Sivov
75c019074a vkd3d-shader/hlsl: Allow modifiers on buffer declarations. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-03-08 23:35:40 +01:00
Nikolay Sivov
b13d60d805 vkd3d-shader/hlsl: Add determinant() function. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-03-08 23:35:23 +01:00
Giovanni Mascellani
8723b5d266 vkd3d-shader/ir: Sort each loop by block label. 2024-03-07 23:08:36 +01:00
Giovanni Mascellani
3d4092d9dc vkd3d-shader/ir: Dump the loops in the control flow graph. 2024-03-07 23:08:35 +01:00
Giovanni Mascellani
8241ca2b67 vkd3d-shader/ir: Keep track of loops by header block. 2024-03-07 23:08:34 +01:00
Giovanni Mascellani
088a6c49a2 vkd3d-shader/ir: Keep a reference to the message context inside struct vsir_cfg. 2024-03-07 23:08:33 +01:00
Giovanni Mascellani
9ac842b36b vkd3d-shader/ir: Compute the loops in the control flow graph. 2024-03-07 23:08:32 +01:00
Giovanni Mascellani
de15f55477 vkd3d-shader/ir: Introduce a helper to express block domination. 2024-03-07 23:08:31 +01:00
Giovanni Mascellani
c3657c4799 vkd3d-shader/ir: Add a debug buffer to struct vsir_cfg. 2024-03-07 23:08:30 +01:00
Giovanni Mascellani
c5893288d9 vkd3d-shader/ir: Properly handle function-local indexable temps when flattening control flow. 
They have to be considered code rather than declarations, as required
for instance by the SPIR-V backend.
 2024-03-07 23:08:28 +01:00
Giovanni Mascellani
9aa86901e3 vkd3d-shader/d3d-asm: Support emitting the shader signature. 2024-03-07 23:08:24 +01:00
Giovanni Mascellani
01a687a7fc vkd3d-shader/d3d-asm: Refactor dumping a write mask to a dedicated function. 2024-03-07 23:08:23 +01:00
Giovanni Mascellani
9d99389663 vkd3d-shader/d3d-asm: Describe the ASM dialect with a bunch of flags instead of a plain enum. 2024-03-07 23:08:22 +01:00
Giovanni Mascellani
94d641783b vkd3d-shader/d3d-asm: Do not make a copy of the buffer before returning it. 2024-03-07 23:08:20 +01:00
Nikolay Sivov
a0d52dc385 vkd3d-shader/hlsl: Improve VertexShader/PixelShader types handling. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-03-06 23:04:25 +01:00
Nikolay Sivov
437ef0896f vkd3d-shader/fx: Make sure to set error message for unimplemented cases. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-03-06 23:04:22 +01:00
Nikolay Sivov
8c5db57ea7 vkd3d-shader/fx: Reject fx_2_0 output without techniques. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-03-06 23:04:19 +01:00
Nikolay Sivov
dd5e42d347 vkd3d-shader/hlsl: Allow technique10 {} blocks for fx_2_0. 
Such techniques are ignored later, but do not cause compilation errors.

Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-03-06 23:04:18 +01:00
Nikolay Sivov
5edbccd33b vkd3d-shader/hlsl: Add keyword tokens for fx_5_0 shader object types. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-03-06 23:04:16 +01:00
Conor McCarthy
5082893e5d vkd3d-shader/spirv: Always use a 64-bit write mask for IMMCONST64 src params. 
There is no way to tell in spirv_compiler_emit_load_reg() if the write
mask is 64-bit. All loads are 32-bit except for IMMCONST64 and SSA, and
the latter ignores the mask, so the only issue lies with IMMCONST64.
 2024-03-06 23:04:12 +01:00
Francisco Casas
58c456ff2b vkd3d-shader/d3dbc: Implement bool to float cast as MOV. 
In SM1, bools are always represented as either 0.0f or 1.0f at runtime.
 2024-03-06 23:04:07 +01:00
Francisco Casas
747511131d vkd3d-shader/hlsl: Lower non-float operators for SM1. 2024-03-06 23:04:05 +01:00
Francisco Casas
a3319339e4 vkd3d-shader/hlsl: Lower casts to int using REINTERPRET instead. 
I realized that it is better to lower casts to int to FLOOR+REINTERPET
instead of appending a FLOOR to all casts to int and assuming that this
is the case for all of them in d3dbc.c.

This in case we introduce new passes in the future that add casts that
we forget to lower, after the lower_casts_to_bool pass.
 2024-03-06 23:04:04 +01:00
Nikolay Sivov
937d76507d vkd3d-shader/hlsl: Implement ternary operator for older vertex profiles. 
Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=56333
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-03-06 23:03:59 +01:00
Henri Verbeet
f866fb95ad Release 1.11. 2024-03-05 20:39:45 +01:00
Zebediah Figura
9177df883e vkd3d-shader/hlsl: Write the SFI0 section and "REQUIRES_ROVS" flag when ROVs are used. 2024-03-04 22:34:46 +01:00
Victor Chiletto
7e27ae73af vkd3d-shader/hlsl: Fix hlsl_ir_resource_store::resource cleanup. 2024-02-26 23:03:51 +01:00
Conor McCarthy
c083b1d0fc vkd3d-shader/dxil: Implement DX intrinsic GetDimensions. 2024-02-26 23:03:48 +01:00
Conor McCarthy
292bbdefbf vkd3d-shader/dxil: Move the resource kind helper functions up. 2024-02-26 23:03:46 +01:00
Henri Verbeet
d65f331efc configure: Build with -Wwrite-strings. 
libs/vkd3d-shader/hlsl.c: In function ‘declare_predefined_types’:
libs/vkd3d-shader/hlsl.c:3408:10: warning: initialization discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers]
         {"technique",    9},
          ^~~~~~~~~~~
...
programs/vkd3d-compiler/main.c: In function ‘parse_formatting’:
programs/vkd3d-compiler/main.c:303:10: warning: initialization discards ‘const’ qualifier from pointer target type [-Wdiscarded-qualifiers]
         {"colour",  VKD3D_SHADER_COMPILE_OPTION_FORMATTING_COLOUR},
          ^~~~~~~~
...

macOS tigetstr() takes a non-const char *, so account for that as well.
 2024-02-22 22:46:29 +01:00
Henri Verbeet
7029d821be configure: Build with -Wtype-limits. 
libs/vkd3d-shader/tpf.c: In function ‘write_sm4_unary_op_with_two_destinations’:
libs/vkd3d-shader/tpf.c:4489:24: warning: comparison of unsigned expression >= 0 is always true [-Wtype-limits]
     assert(1 - dst_idx >= 0);
                        ^~
libs/vkd3d-shader/tpf.c: In function ‘write_sm4_binary_op_with_two_destinations’:
libs/vkd3d-shader/tpf.c:4549:24: warning: comparison of unsigned expression >= 0 is always true [-Wtype-limits]
     assert(1 - dst_idx >= 0);
                        ^~
 2024-02-22 22:46:22 +01:00
Conor McCarthy
ba4bd651e5 vkd3d-shader/dxil: Implement DX intrinsics SampleCmp and SampleCmpLevelZero. 2024-02-22 22:45:36 +01:00
Conor McCarthy
2330ffdeda vkd3d-shader/dxil: Implement DX intrinsics SampleBias and SampleLevel. 2024-02-22 22:45:34 +01:00
Zebediah Figura
87b1de94da vkd3d-shader/hlsl: Check the resource format for UAVs also in hlsl_types_are_equal(). 
Spotted by Henri Verbeet.
 2024-02-22 22:45:31 +01:00
Nikolay Sivov
5474d91804 vkd3d-shader/fx: Write DepthStencilView types. 2024-02-22 22:45:27 +01:00
Nikolay Sivov
371be3b60a vkd3d-shader/hlsl: Add DepthStencilView object type. 2024-02-22 22:45:26 +01:00
Nikolay Sivov
9632adaaec vkd3d-shader/fx: Handle fx_4+ UAV types. 2024-02-22 22:45:24 +01:00
Nikolay Sivov
e5f4f60214 vkd3d-shader/fx: Handle fx_4+ texture types. 2024-02-22 22:45:23 +01:00
Nikolay Sivov
a6057a1365 vkd3d-shader/fx: Add initial support for writing object variables. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-02-22 22:45:22 +01:00
Nikolay Sivov
c2b1714c5c vkd3d-shader/hlsl: Add RenderTargetView object type. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-02-22 22:45:21 +01:00
Giovanni Mascellani
9c678532a7 vkd3d-shader/ir: Dump the domination relationship. 2024-02-22 22:45:16 +01:00
Giovanni Mascellani
04c2852c1a vkd3d-shader/ir: Compute the domination relationship. 2024-02-22 22:45:15 +01:00
Giovanni Mascellani
2573d86ccf vkd3d-shader/ir: Dump the control flow graph in the GraphViz format. 2024-02-22 22:45:14 +01:00
Giovanni Mascellani
da037b61ba vkd3d-shader/ir: Build a representation of the control flow graph. 2024-02-22 22:45:13 +01:00
Conor McCarthy
1dffc281c9 vkd3d-shader/dxil: Implement DX intrinsic RawBufferStore. 2024-02-22 22:45:08 +01:00
Conor McCarthy
cab8b781ab vkd3d-shader/dxil: Handle raw and structured buffers in sm6_parser_emit_dx_buffer_store(). 2024-02-22 22:45:07 +01:00
Conor McCarthy
ce1875c435 vkd3d-shader/dxil: Implement DX intrinsic BufferStore. 2024-02-22 22:45:06 +01:00
Petrichor Park
02a3667822 vkd3d-shader/hlsl: Implement atan and atan2. 
Also narrows some more todos on the tests.
 2024-02-21 23:23:13 +01:00
Petrichor Park
69294c290b vkd3d-shader/hlsl: Implement acos and asin trig intrinsics. 
Tests have already been implemented in 92044d5e; this commit also reduces
the scope of some of the todos (because now they're implemented!).

Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=55154
 2024-02-21 23:23:11 +01:00
Henri Verbeet
d4223a03c8 vkd3d-shader/hlsl: Replace HLSL_MODIFIER_RASTERIZER_ORDERED with a hlsl_type.e.resource flag. 2024-02-21 23:23:08 +01:00
Henri Verbeet
49d14613a5 vkd3d-shader/hlsl: Introduce hlsl_type.e.resource. 2024-02-21 23:23:06 +01:00
Conor McCarthy
d9c68ee481 vkd3d-shader/dxil: Handle resource descriptor additional tag/value pairs. 
These are tag/value pairs, and the current code only works if an element
type or element stride pair is present at index zero.
 2024-02-20 22:50:19 +01:00
Conor McCarthy
96a0685ba6 vkd3d-shader/dxil: Implement DX intrinsic AtomicCompareExchange. 2024-02-20 22:50:16 +01:00
Conor McCarthy
560c9413c3 vkd3d-shader/dxil: Implement DX intrinsic AtomicBinOp. 2024-02-20 22:50:15 +01:00
Evan Tang
7b41abaa1b vkd3d-shader/hlsl: Support SV_PrimitiveID in pixel shaders. 2024-02-19 21:12:23 +01:00
Francisco Casas
8df34fce62 vkd3d-shader/hlsl: Emit fixme on non-direct resource stores. 
Co-authored-by: Giovanni Mascellani <gmascellani@codeweavers.com>

These may happen when storing to structured buffers, and we are not
handling them properly yet. The included test reaches unreacheable code
before this patch.

Storing to buffers is complicated since we need to split the index
chain in two paths:
- The path within the variable where the resource is.
- The subpath to the part of the resource element that is being stored
  to.

For now, we will emit a fixme when the index chain in the lhs is not a
direct resource access.
 2024-02-19 21:12:14 +01:00
Nikolay Sivov
315b7c5a42 vkd3d-shader/fx: Do not align structured data section. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-02-19 21:12:09 +01:00
Nikolay Sivov
c107ec03b8 vkd3d-shader/fx: Add initial support for writing buffers descriptions. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-02-19 21:12:08 +01:00
Nikolay Sivov
656c068b32 vkd3d-shader/fx: Do not align strings for fx_4/fx_5 profiles. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-02-19 21:12:07 +01:00
Nikolay Sivov
d5f562d994 vkd3d-shader/fx: Use variable pointer in write_group(). 
The helper will need to access group annotations later, and these are
available for variables.

Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-02-19 21:12:05 +01:00
Francisco Casas
c249461e97 vkd3d-shader/hlsl: Parse Buffer types. 2024-02-19 21:11:55 +01:00
Francisco Casas
e1c759e1c9 vkd3d-shader/hlsl: Record valid methods in object_methods[]. 
Also, call hlsl_sampler_dim_count() and hlsl_offset_dim_count() after
type checking, to avoid reaching unreacheable cases.
 2024-02-19 21:11:46 +01:00
Evan Tang
ee867bd470 vkd3d-shader/hlsl: Parse rasteriser-ordered view types. 2024-02-15 23:29:46 +01:00
Francisco Casas
e3ed5ac77e vkd3d-shader/hlsl: Lower casts to int for SM1. 2024-02-15 23:29:39 +01:00
Francisco Casas
4b5c7e3721 vkd3d-shader/d3dbc: Implement casts from ints to floats as a MOV. 
For temporary registers, SM1-SM3 integer types are internally
represented as floating point, so, in order to perform a cast
from ints to floats we need a mere MOV.

For constant integer registers "iN" there is no operation for casting
from a floating point register to them. For address registers "aN", and
the loop counting register "aL", vertex shaders have the "mova" operation
but we haven't used these registers in any way yet.

We probably would want to introduce these as synthetic variables
allocated in a special register set. In that case we have to remember to
use MOVA instead of MOV in the store operations, but they shouldn't be src
or dst of CAST operations.

Regarding constant integer registers, in some shaders, constants are
expected to be received formatted as an integer, such as:

    int m;
    float4 main() : sv_target
    {
        float4 res = {0, 0, 0, 0};

        for (int k = 0; k < m; ++k)
            res += k;
        return res;
    }

which compiles as:

    // Registers:
    //
    //   Name         Reg   Size
    //   ------------ ----- ----
    //   m            i0       1
    //

    ps_3_0
    def c0, 0, 1, 0, 0
    mov r0, c0.x
    mov r1.x, c0.x
    rep i0
      add r0, r0, r1.x
      add r1.x, r1.x, c0.y
    endrep
    mov oC0, r0

but this only happens if the integer constant is used directly in an
instruction that needs it, and as I said there is no instruction that
allows converting them to a float representation.

Notice how a more complex shader, that performs operations with this
integer variable "m":

    int m;
    float4 main() : sv_target
    {
        float4 res = {0, 0, 0, 0};

        for (int k = 0; k < m * m; ++k)
            res += k;
        return res;
    }

gives the following output:

    // Registers:
    //
    //   Name         Reg   Size
    //   ------------ ----- ----
    //   m            c0       1
    //

    ps_3_0
    def c1, 0, 0, 1, 0
    defi i0, 255, 0, 0, 0
    mul r0.x, c0.x, c0.x
    mov r1, c1.y
    mov r0.y, c1.y
    rep i0
      mov r0.z, r0.x
      break_ge r0.y, r0.z
      add r1, r0.y, r1
      add r0.y, r0.y, c1.z
    endrep
    mov oC0, r1

Meaning that the uniform "m" is just stored as a floating point in
"c0", the constant integer register "i0" is just set to 255 (hoping
it is a high enough value) using "defi", and the "break_ge"
involving c0 is used to break from the loop.

We could potentially use this approach to implement loops from SM3
without expecting the variables being received as constant integer
registers.

According to the D3D documentation, for SM1-SM3 constant integer
registers are only used by the 'loop' and 'rep' instructions.
 2024-02-15 23:29:37 +01:00
Conor McCarthy
6e634ad690 vkd3d-shader: Raise the instruction parameter allocation size if necessary. 
Monolithic switch instructions have no definite case count limit.
 2024-02-14 21:48:38 +01:00
Conor McCarthy
55c28e94f8 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_vselect(). 2024-02-14 21:48:32 +01:00
Conor McCarthy
c89627ec73 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_store(). 2024-02-14 21:48:31 +01:00
Conor McCarthy
4c7d956bdb vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_load(). 2024-02-14 21:48:30 +01:00
Conor McCarthy
04a9340164 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_extractval(). 2024-02-14 21:48:28 +01:00
Conor McCarthy
3c1ad054f0 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_cmp2(). 2024-02-14 21:48:26 +01:00
Conor McCarthy
cddb696499 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_cast(). 2024-02-14 21:48:25 +01:00
Conor McCarthy
76455580e2 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_dx_texture_load(). 2024-02-14 21:48:24 +01:00
Conor McCarthy
d04a8ea893 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_dx_split_double(). 2024-02-14 21:48:23 +01:00
Conor McCarthy
8c3512bd10 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_dx_sincos(). 2024-02-14 21:48:22 +01:00
Conor McCarthy
cc5293bb4f vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_dx_buffer_load(). 2024-02-14 21:48:21 +01:00
Conor McCarthy
6e3e200e96 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_dx_load_input(). 2024-02-14 21:48:20 +01:00
Conor McCarthy
eb1bfaa821 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_dx_tertiary(). 2024-02-14 21:48:19 +01:00
Conor McCarthy
1a2de25273 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_dx_cbuffer_load(). 2024-02-14 21:48:18 +01:00
Conor McCarthy
0a23c81196 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_dx_binary(). 2024-02-14 21:48:17 +01:00
Conor McCarthy
83e6ee4b3d vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_dx_unary(). 2024-02-14 21:48:14 +01:00
Conor McCarthy
217eb06f37 vkd3d-shader/dxil: Check for src param allocation failure in sm6_parser_emit_binop(). 2024-02-14 21:48:13 +01:00
Conor McCarthy
5a76cedf87 vkd3d-shader/dxil: Implement DX intrinsic SampleGrad. 2024-02-14 21:48:08 +01:00
Conor McCarthy
5178fb7364 vkd3d-shader/dxil: Implement DX intrinsic Sample. 2024-02-14 21:48:06 +01:00
Conor McCarthy
0a3eb61170 vkd3d-shader/dxil: Load sampler descriptors. 2024-02-14 21:48:03 +01:00
Giovanni Mascellani
5905489b7f vkd3d-shader/hlsl: Free the selector in postfix_expr (Valgrind). 2024-02-09 22:47:46 +01:00
Giovanni Mascellani
a10de1b239 vkd3d-shader/hlsl: Free the individual attributes in func_prototype (Valgrind). 2024-02-09 22:47:45 +01:00
Giovanni Mascellani
049327a270 vkd3d-shader/hlsl: Free the parse initializer in attribute (Valgrind). 2024-02-09 22:47:44 +01:00
Giovanni Mascellani
521082afbe vkd3d-shader/hlsl: Free variable identifiers in primary_expr (Valgrind). 2024-02-09 22:47:42 +01:00
Conor McCarthy
625e289574 vkd3d-shader/dxil: Handle hyperbolic trigonometric functions in sm6_parser_emit_dx_unary(). 2024-02-07 22:59:23 +01:00
Conor McCarthy
c35ec4f820 vkd3d-shader/dxil: Implement DX intrinsic TextureStore. 2024-02-07 22:59:18 +01:00
Conor McCarthy
efddcc9a99 vkd3d-shader/dxil: Support forward-referenced value ids. 2024-02-07 22:59:10 +01:00
Conor McCarthy
7f87a3e5fc vkd3d-shader/spirv: Handle the ACOS, ASIN and ATAN instructions in spirv_compiler_emit_ext_glsl_instruction(). 2024-02-06 23:09:55 +01:00
Conor McCarthy
19d23fa696 vkd3d-shader/dxil: Handle inverse trigonometric functions in sm6_parser_emit_dx_unary(). 2024-02-06 23:09:53 +01:00
Giovanni Mascellani
51f13391e6 vkd3d-shader/ir: Introduce a simple control flow graph structurizer. 
The structurizer is implemented along the lines of what is usually called
the "structured program theorem": the control flow is completely
virtualized by mean of an additional TEMP register which stores the
block index which is currently running. The whole program is then
converted to a huge switch construction enclosed in a loop, executing
at each iteration the appropriate block and updating the register
depending on block jump instruction.

The algorithm's generality is also its major weakness: it accepts any
input program, even if its CFG is not reducible, but the output
program lacks any useful convergence information. It satisfies the
letter of the SPIR-V requirements, but it is expected that it will
be very inefficient to run on a GPU (unless a downstream compiler is
able to devirtualize the control flow and do a proper convergence
analysis pass). The algorithm is however very simple, and good enough
to at least pass tests, enabling further development. A better
alternative is expected to be upstreamed incrementally.

Side note: the structured program theorem is often called the
Böhm-Jacopini theorem; Böhm and Jacopini did indeed prove a variation
of it, but their algorithm is different from what is commontly attributed
to them and implemented here, so I opted for not using their name.
 2024-02-06 23:07:07 +01:00
Giovanni Mascellani
19aef21369 vkd3d-shader/ir: Handle PHI nodes when materializing SSA registers. 
PHI nodes cannot be used with TEMP registers, so they have to be
converted to MOV/MOVC nodes and moved before the BRANCH node.
 2024-02-06 23:07:03 +01:00
Giovanni Mascellani
e0d3e9c376 vkd3d-shader/ir: Materialize SSA registers to temporaries. 
For simplicity PHI nodes are not currently handled.

The goal for this pass is to make the CFG structurizer simpler, because
it doesn't have to care about the more rigid rules SSA registers have
to satisfy than TEMP registers.

It is likely that the generated code will be harder for downstream
compilers to optimize and execute efficiently, so once a complete
structurizer is in place this pass should be removed, or at least
greatly reduced in scope.
 2024-02-06 23:07:00 +01:00
Giovanni Mascellani
eb723a8d2b vkd3d-shader/spirv: Support bool TEMP registers. 2024-02-06 23:06:58 +01:00
Giovanni Mascellani
49f0fd42b8 vkd3d-shader/spirv: Move bool casting helpers above register loading helpers. 2024-02-06 23:06:55 +01:00
Giovanni Mascellani
ee994e95dd vkd3d-shader/spirv: Convert the swizzle according to the source bit width. 
Fixes: 1f536238a8
 2024-02-06 23:06:53 +01:00
Giovanni Mascellani
674f86042d vkd3d-shader/dxil: Set the register before calling src_param_init_scalar(). 
Which uses the register to compute the appropriate swizzle.

Fixes: 1f536238a8
 2024-02-06 23:06:49 +01:00
Conor McCarthy
95e4222cc6 vkd3d-shader/spirv: Emit a vector bitcast if necessary in spirv_compiler_emit_load_ssa_reg(). 2024-02-01 22:25:04 +01:00
Conor McCarthy
ebec0aa434 vkd3d-shader/dxil: Implement DX intrinsic TextureLoad. 2024-02-01 22:25:02 +01:00
Conor McCarthy
e6d52861e9 vkd3d-shader/dxil: Implement DX intrinsic SplitDouble. 2024-02-01 22:24:58 +01:00
Giovanni Mascellani
cc72a8d311 vkd3d-shader/spirv: Free binary SPIR-V code (Valgrind). 2024-02-01 00:08:28 +01:00
Henri Verbeet
d38221bd68 vkd3d-shader/ir: Pass a struct vsir_program to shader_parser_get_src_params(). 2024-02-01 00:08:23 +01:00
Henri Verbeet
47ec24ebad vkd3d-shader/ir: Pass a struct vsir_program to shader_parser_get_dst_params(). 2024-02-01 00:08:22 +01:00
Henri Verbeet
ced8543952 vkd3d-shader: Use vkd3d_atomic_increment_u32() in vkd3d_shader_dump_blob(). 2024-02-01 00:08:18 +01:00
Henri Verbeet
fef30dac2c vkd3d-shader/d3dbc: Do not fail parsing the shader when undeclared inputs are encountered. 
These can be disassembled by D3DDisassemble() just fine, and perhaps
more importantly, shader model 1 vertex shaders do not require dcl_
instructions in Direct3D 8.
 2024-01-29 22:33:46 +01:00
Giovanni Mascellani
edc406d297 vkd3d-shader/ir: Check that SSA registers are used with compatible data types. 
Specifically, accesses are always 32 bit or always 64 bit.
 2024-01-29 22:33:34 +01:00
Giovanni Mascellani
1f536238a8 vkd3d-shader: Use 64 bit swizzles for 64 bit data types in VSIR. 
The handling of write masks and swizzles for 64 bit data types is
currently irregular: write masks are always 64 bit, while swizzles
are usually 32 bit, except for SSA registers with are 64 bit.
With this change we always use 64 bit swizzles, in order to make
the situation less surprising and make it easier to convert
registers between SSA and TEMP.

64 bit swizzles are always required to have X in their last two
components.
 2024-01-29 22:33:33 +01:00
Giovanni Mascellani
2b93aae069 vkd3d-shader: Convert write masks between 32 and 64 bit by cases. 
There are only three cases, and while the code is longer it is also
hopefully easier to read. Moreover, an error message is casted if
we're doing something unexpected.
 2024-01-29 22:33:30 +01:00
Francisco Casas
13f713f74b vkd3d-shader/hlsl: Turn register(cX) reservations into buffer offset for SM4. 2024-01-29 22:33:27 +01:00
Francisco Casas
c7f7636534 vkd3d-shader/hlsl: Make register(cX) reservations work for SM1. 2024-01-29 22:33:25 +01:00
Conor McCarthy
92f0b37133 vkd3d-shader/spirv: Support 64-bit source value for bitfield instructions. 2024-01-29 22:33:22 +01:00
Conor McCarthy
3bbe374ca8 vkd3d-shader/dxil: Implement DX intrinsic Tertiary. 
IBFE and UBFE are not emitted for HLSL sources which perform bitfield
extractions, e.g. loading a value from a struct containing bitfields, or
the equivalent done with bit shifts. These instructions are probably
only emitted by the TPF -> DXIL converter, which makes them hard to test.
 2024-01-29 22:33:20 +01:00
Giovanni Mascellani
026c502f31 vkd3d-shader/ir: Fixup PHI nodes when lowering switches to selection ladders. 
A map between the blocks before and after the pass is built and then
used to fix the PHI nodes.
 2024-01-29 22:33:17 +01:00
Giovanni Mascellani
378109051c vkd3d-shader/ir: Lower monolithic switches to selection ladders. 
PHI nodes must be fixed up after this pass, because the block references
might have become broken. For simplicitly this is not handled yet.

The goal for this pass is to make the CFG structurizer simpler, because
only conditional and unconditional branches must be supported.
Eventually this limitation might be lifted if there is advantage in
doing so.
 2024-01-29 22:33:15 +01:00
Giovanni Mascellani
b97edee03d vkd3d-shader/spirv: Emit an error if merge information is missing. 
Instead of crashing.
 2024-01-29 22:33:14 +01:00
Conor McCarthy
e08c0cfc4f vkd3d-shader/dxil: Implement DX intrinsic RawBufferLoad. 2024-01-29 22:33:10 +01:00
Conor McCarthy
1bab93843d vkd3d-shader/dxil: Load raw/structured buffer SRV/UAV descriptors. 2024-01-29 22:33:09 +01:00
Henri Verbeet
fee3b94563 vkd3d-shader: Start an if-block on VKD3DSIH_IFC in vkd3d_shader_scan_instruction(). 2024-01-25 22:24:50 +01:00
Conor McCarthy
f954724870 vkd3d-shader/spirv: Handle the TAN instruction in spirv_compiler_emit_ext_glsl_instruction(). 2024-01-25 22:24:44 +01:00
Conor McCarthy
93d7c30395 vkd3d-shader/dxil: Handle DX intrinsic Tan in sm6_parser_emit_dx_unary(). 2024-01-25 22:24:43 +01:00
Conor McCarthy
2a260b8d56 vkd3d-shader/dxil: Implement DX intrinsics Cos and Sin. 2024-01-25 22:24:41 +01:00
Francisco Casas
cec45da45b vkd3d-shader/ir: Update flatten_control_flow_constructs() comment. 2024-01-25 22:24:27 +01:00
Conor McCarthy
8ae69c745b vkd3d-shader/spirv: Handle thread group UAV barriers. 2024-01-25 22:24:23 +01:00
Conor McCarthy
18e9148f58 vkd3d-shader/spirv: Include Uniform in the memory semantics for UAV barriers. 
The UniformMemory semantic applies the constraints to Uniform storage
class memory, which matches how UAV variables are declared.
 2024-01-25 22:24:22 +01:00
Conor McCarthy
adfbecef3c vkd3d-shader/spirv: Handle globally coherent UAVs. 2024-01-25 22:24:20 +01:00
Henri Verbeet
eabcaf15fb vkd3d-shader/ir: Use vsir_instruction_is_dcl() in vsir_validate_instruction(). 2024-01-24 22:38:36 +01:00
Henri Verbeet
365ad56888 vkd3d-shader/ir: Get rid of shader_instruction_is_dcl(). 2024-01-24 22:38:34 +01:00
Conor McCarthy
54f6e6dd67 vkd3d-shader/spirv: Check for FEATURE_FLOAT64 when double precision use is flagged. 2024-01-24 22:38:09 +01:00
Conor McCarthy
e973271a40 vkd3d-shader/spirv: Handle the ISINF and ISNAN instructions in spirv_compiler_emit_alu_instruction(). 2024-01-24 22:38:04 +01:00
Conor McCarthy
cd674d593e vkd3d-shader/spirv: Implement the ISFINITE instruction. 2024-01-24 22:38:03 +01:00
Conor McCarthy
41cce4cbf1 vkd3d-shader/dxil: Handle floating point special value comparisons in sm6_parser_emit_dx_unary(). 2024-01-24 22:37:59 +01:00
Francisco Casas
b92f6c448a vkd3d-shader/ir: Lower texkill instructions to discard_nz. 2024-01-24 22:37:41 +01:00
Francisco Casas
7e75ac63a1 vkd3d-shader/d3dbc: Emit fixme for HLSL_RESOURCE_SAMPLE_LOD. 
Currently, HLSL_RESOURCE_SAMPLE_LOD is not implemented for d3dbc,
but we are incorrectly writting a texld instruction to handle it.
This causes SM1 tests with the vulkan backend (in following patches)
to fail if VKD3D_SHADER_CONFIG="force_validation" is enabled.

For now a fixme is emited in these cases.
 2024-01-24 22:37:38 +01:00
Henri Verbeet
bf628f0c74 vkd3d-shader/ir: Store block names in struct vsir_program. 2024-01-23 20:27:35 +01:00
Henri Verbeet
f3c7d2d05c vkd3d-shader/ir: Store the block count in struct vsir_program. 2024-01-23 20:27:34 +01:00
Henri Verbeet
98c6e85b33 vkd3d-shader/ir: Store control point counts in struct vsir_program. 2024-01-23 20:27:32 +01:00
Conor McCarthy
e4660fe0e6 vkd3d-shader/spirv: Emit DISCARD as a function call. 2024-01-23 20:26:59 +01:00
Conor McCarthy
367a06d748 vkd3d-shader/dxil: Use strcmp() to find the handle type. 
We use strcmp() on the same type name elsewhere, and case-insensitive
matching does not seem necessary.
 2024-01-23 20:26:53 +01:00
Conor McCarthy
1cca18a228 vkd3d-shader/dxil: Use strcmp() to find function names. 
Function names are case-sensitive.
 2024-01-23 20:26:52 +01:00
Conor McCarthy
4dec25cbde vkd3d-shader/dxil: Use strcmp() to check the entry point name. 
Function names are case-sensitive.
 2024-01-23 20:26:50 +01:00
Zebediah Figura
a8b0c03912 vkd3d-shader/hlsl: Always cast to bool in if() statements. 
We emit sm4 if_nz for these, but that does a bitwise comparison to zero, which is wrong for floats.
 2024-01-23 20:26:46 +01:00
Zebediah Figura
183172eff4 vkd3d-shader/hlsl: Validate that condition expressions are numeric. 2024-01-23 20:26:45 +01:00
Zebediah Figura
09220edd21 vkd3d-shader/hlsl: Validate the condition data type for loops as well. 2024-01-23 20:26:44 +01:00
Zebediah Figura
c18a349a3f vkd3d-shader/hlsl: Copy some missing fields in hlsl_type_clone(). 2024-01-23 20:26:42 +01:00
Giovanni Mascellani
de9725b6ba vkd3d-shader/ir: Remove DCL_TEMPS instructions. 
We have to do work to keep it updated across passes and we never read it.
 2024-01-23 20:26:38 +01:00
Giovanni Mascellani
4b869f73bb vkd3d-shader/ir: Run tracing and validation for DXIL code too. 2024-01-23 20:26:36 +01:00
Conor McCarthy
6df725718a vkd3d-shader/ir: Refactor return code checking in vkd3d_shader_normalise(). 
We started with only one or two of these but it has become excessive.

Patch originally written by Conor McCarthy and updated by Giovanni Mascellani.
 2024-01-23 20:26:34 +01:00
Conor McCarthy
b3903636f7 vkd3d-shader/dxil: Implement DX intrinsic Binary. 2024-01-23 20:26:29 +01:00
Conor McCarthy
6c71cd5a72 vkd3d-shader/dxil: Add an operand type code for the return type. 2024-01-23 20:26:28 +01:00
Nikolay Sivov
0117e4fb7e vkd3d-shader/fx: Add initial support for writing passes for fx_2_0. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-23 20:26:22 +01:00
Nikolay Sivov
b478f0a300 vkd3d-shader/fx: Add initial support for writing fx_2_0 binaries. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-23 20:26:21 +01:00
Nikolay Sivov
56100d36b1 vkd3d-shader/fx: Check technique type in global scope as well. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-23 20:26:20 +01:00
Nikolay Sivov
2c1905b780 vkd3d-shader/hlsl: Allow annotations on techniques. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-23 20:26:19 +01:00
Nikolay Sivov
76a689d43f vkd3d-shader/hlsl: Allow annotations on passes. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-23 20:26:18 +01:00
Nikolay Sivov
e72f8f9a30 vkd3d-shader/hlsl: Add passes variables to the techniques. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-23 20:26:16 +01:00
Nikolay Sivov
fe8881747b vkd3d-shader/hlsl: Add initial support for parsing annotations. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-23 20:26:15 +01:00
Giovanni Mascellani
232b2ad360 vkd3d-shader/ir: Validate PHI instructions. 2024-01-23 20:26:08 +01:00
Giovanni Mascellani
56f9057985 vkd3d-shader/ir: Do not allow IMMCONST and IMMCONST64 as destination registers. 2024-01-23 20:26:06 +01:00
Giovanni Mascellani
21633fcc52 vkd3d-shader/ir: Refactor register-type-specific code in parameter validation. 
To better accommodate code for other register types.
 2024-01-23 20:26:05 +01:00
Giovanni Mascellani
fb6409bda1 vkd3d-shader/ir: Check that all instructions appear in a block. 2024-01-23 20:26:03 +01:00
Giovanni Mascellani
dc56320b31 vkd3d-shader/tpf: Support SV_ViewportArrayIndex in pixel and vertex shaders. 2024-01-22 22:19:14 +01:00
Giovanni Mascellani
3a90f3e29d vkd3d-shader/tpf: Support SV_InstanceID in vertex shaders. 2024-01-22 22:19:13 +01:00
Giovanni Mascellani
b500381b5c vkd3d-shader/tpf: Support SV_RenderTargetArrayIndex in pixel and vertex shaders. 2024-01-22 22:19:12 +01:00
Giovanni Mascellani
45495f54f2 vkd3d-shader/spirv: Use capability ShaderViewportIndexLayerEXT for decoration ViewportIndex. 2024-01-22 22:19:11 +01:00
Giovanni Mascellani
6ac525d6c3 vkd3d-shader/spirv: Use capability ShaderViewportIndexLayerEXT for decoration Layer. 
Capability Geometry allows to use the Layer builtin in geometry and pixel
shaders. For vertex and domain shaders ShaderLayer should be used, but it's only
available starting from SPIR-V 1.5. ShaderViewportIndexLayerEXT can be used
instead with extension SPV_EXT_shader_viewport_index_layer.
 2024-01-22 22:19:09 +01:00
Henri Verbeet
adc02eada8 vkd3d-shader/ir: Store the temporary register count in struct vsir_program. 2024-01-22 22:18:53 +01:00
Henri Verbeet
94ca46916a vkd3d-shader/ir: Store the SSA register count in struct vsir_program. 2024-01-22 22:18:52 +01:00
Henri Verbeet
7b85cd6a31 vkd3d-shader/ir: Store the "use_vocp" field in struct vsir_program. 2024-01-22 22:18:51 +01:00
Henri Verbeet
23dcd4f22b vkd3d-shader/ir: Store the shader version in struct vsir_program. 2024-01-22 22:18:50 +01:00
Henri Verbeet
fc9043be3c vkd3d-shader/ir: Introduce struct vsir_program. 2024-01-22 22:18:48 +01:00
Conor McCarthy
55c7cd5c22 vkd3d-shader/dxil: Handle semantic kind ISFRONTFACE. 2024-01-22 22:18:33 +01:00
Conor McCarthy
9f409b67d7 vkd3d-shader/dxil: Handle semantic kind VERTEXID. 2024-01-22 22:18:32 +01:00
Conor McCarthy
ca7487a56d vkd3d-shader/spirv: Handle UINT32_MAX result from FIRSTBIT_HI and FIRSTBIT_SHI instructions. 2024-01-22 22:18:27 +01:00
Conor McCarthy
bfdc8b31a3 vkd3d-shader/dxil: Implement DX intrinsic BufferLoad for typed buffers. 2024-01-22 22:18:21 +01:00
Conor McCarthy
85052ba93e vkd3d-shader/dxil: Load typed UAV descriptors. 2024-01-22 22:18:19 +01:00
Conor McCarthy
89d1ef83f4 vkd3d-shader/dxil: Load typed SRV descriptors. 2024-01-22 22:18:18 +01:00
Conor McCarthy
5ebe0cc717 vkd3d-shader/spirv: Do not assert VKD3D_DATA_UINT in spirv_compiler_emit_ld_raw_structured_srv_uav(). 2024-01-22 22:18:17 +01:00
Conor McCarthy
80d7ea2924 vkd3d-shader/dxil: Pass the code block and instruction in a struct to intrinsic handlers. 
Simplifies handling of intrinsics which need to emit more than one
instruction.
 2024-01-22 22:18:16 +01:00
Henri Verbeet
f69c8b1cc4 vkd3d-shader/d3dbc: Store the "offset" field as an unsigned int in hlsl_sm1_register_from_semantic(). 2024-01-18 23:16:06 +01:00
Giovanni Mascellani
67902d4304 vkd3d-shader/ir: Validate RET instructions. 2024-01-18 23:15:58 +01:00
Giovanni Mascellani
af96730276 vkd3d-shader/ir: Validate SWITCH_MONOLITHIC instructions. 2024-01-18 23:15:57 +01:00
Giovanni Mascellani
46ebb404d7 vkd3d-shader/ir: Validate BRANCH instructions. 2024-01-18 23:15:56 +01:00
Giovanni Mascellani
bc9db34cdc vkd3d-shader/ir: Validate LABEL instructions. 2024-01-18 23:15:55 +01:00
Giovanni Mascellani
dd1b2feec0 vkd3d-shader/ir: Validate LABEL registers. 2024-01-18 23:15:54 +01:00
Giovanni Mascellani
17f4afc2b5 vkd3d-shader/ir: Validate that structured CF does not appear in block-based shaders. 2024-01-18 23:15:53 +01:00
Giovanni Mascellani
1d45b7a422 vkd3d-shader/spirv: Normalise the shader before allocating registers. 
So registers are allocated after normalisation (which could require
additional registers).
 2024-01-18 23:15:48 +01:00
Zebediah Figura
9ad48f16ea vkd3d-shader/hlsl: Forbid mismatched argument types in ternaries. 2024-01-18 23:15:44 +01:00
Zebediah Figura
275901557c vkd3d-shader/hlsl: Handle scalar values in ternaries. 2024-01-18 23:15:43 +01:00
Zebediah Figura
11112798c8 vkd3d-shader/hlsl: Handle scalar conditions in ternaries. 2024-01-18 23:15:42 +01:00
Zebediah Figura
2c8751478f vkd3d-shader/hlsl: Forbid objects in ternary conditions. 2024-01-18 23:15:41 +01:00
Giovanni Mascellani
38fdf24002 vkd3d-shader: Make relative address sources mutable too. 
They were forgotten in 78d95889bd.

Fixes: 78d95889bd
 2024-01-18 23:15:35 +01:00
Conor McCarthy
83851133c5 vkd3d-shader/ir: Set merged signature element interpolation mode only from used elements. 2024-01-18 23:15:27 +01:00
Conor McCarthy
b8280e4210 vkd3d-shader/ir: Revert "Do not merge signature elements which have different interpolation modes.". 
This reverts commit b5c067b41a.

The commit causes regressions in other shaders because unused elements
do not have an interpolation mode.
 2024-01-18 23:15:25 +01:00
Conor McCarthy
efe800f7f0 vkd3d-shader/dxil: Handle the DXIL SWITCH instruction. 2024-01-18 23:15:14 +01:00
Conor McCarthy
ba1ee27b4b vkd3d-shader/dxil: Handle the DXIL PHI instruction. 2024-01-18 23:15:12 +01:00
Conor McCarthy
8a5804eb43 vkd3d-shader/dxil: Handle the DXIL BR instruction conditional variant. 2024-01-18 23:15:10 +01:00
Conor McCarthy
c9493884ef vkd3d-shader/dxil: Handle the DXIL BR instruction unconditional variant. 2024-01-18 23:15:03 +01:00
Conor McCarthy
9e964fa0c7 vkd3d-shader/dxil: Introduce a code block terminator struct. 2024-01-18 23:15:01 +01:00
Conor McCarthy
c40093474e vkd3d-shader/tpf: Validate sysvals in index range declarations. 2024-01-17 22:29:01 +01:00
Conor McCarthy
4c30b23821 vkd3d-shader: Make the control point count the outer dimension of I/O arrays. 
The relative-addressed case in shader_register_normalise_arrayed_addressing()
leaves the control point id in idx[0], while for constant register
indices it is placed in idx[1]. The latter case could be fixed instead,
but placing the control point count in the outer dimension is more
logical.
 2024-01-17 22:28:59 +01:00
Conor McCarthy
418e8d8100 vkd3d-shader/ir: Expand index range write masks to cover all element masks. 
For example, this occurred in a shader:

reg_idx write_mask
   0      xyz
   1      xyzw
   2      xyzw
   3      xyz

The dcl_indexrange instruction covered only xyz, so once merged, searching for
xyzw failed.

It is impossible to declare an input array where elements have different
component counts, but the optimiser can create this case. One way for
this to occur is to dynamically index input values via a local array
containing copies of the input values. The optimiser converts this to
dynamically indexed inputs.
 2024-01-17 22:28:56 +01:00
Zebediah Figura
16962ac6f1 vkd3d-shader/hlsl: Allow non-numeric types in the ternary operator. 2024-01-17 22:28:51 +01:00
Zebediah Figura
46bd099341 vkd3d-shader/hlsl: Separate an add_ternary() helper. 2024-01-17 22:28:50 +01:00
Zebediah Figura
a5549bae38 vkd3d-shader/hlsl: Do not try to lower ternaries of types other than scalar or vector. 2024-01-17 22:28:49 +01:00
Zebediah Figura
e0b1f2e273 vkd3d-shader/hlsl: Remove a redundant definition of the "float" type. 2024-01-17 22:28:47 +01:00
Conor McCarthy
559d9d4ee0 vkd3d-shader/ir: Include an initial label instruction in the first control flow block. 2024-01-17 22:28:41 +01:00
Conor McCarthy
d402804851 vkd3d-shader/spirv: Do not emit function code before the main prolog. 2024-01-17 22:28:40 +01:00
Conor McCarthy
b4b2b0d3ac vkd3d-shader/spirv: Declare indexable temps as Private unless function scope is specified. 2024-01-17 22:28:39 +01:00
Conor McCarthy
37d9dba512 vkd3d-shader/ir: Store code block names in struct vkd3d_shader_desc. 2024-01-17 22:28:38 +01:00
Conor McCarthy
ffc65215ba vkd3d-shader/ir: Flatten SWITCH/CASE/DEFAULT/ENDSWITCH control flow instructions. 2024-01-17 22:28:36 +01:00
Conor McCarthy
dcb8527327 vkd3d-shader/ir: Flatten LOOP/BREAK/CONTINUE/ENDLOOP control flow instructions. 2024-01-17 22:28:35 +01:00
Conor McCarthy
e1dddc01b7 vkd3d-shader/ir: Flatten IF/ELSE/ENDIF control flow instructions. 2024-01-17 22:28:34 +01:00
Conor McCarthy
f3d464de0e vkd3d-shader/spirv: Handle RETP in spirv_compiler_handle_instruction(). 2024-01-17 22:28:33 +01:00
Conor McCarthy
bc1b5e7132 vkd3d-shader/spirv: Handle DISCARD and TEXKILL in spirv_compiler_handle_instruction(). 2024-01-17 22:28:31 +01:00
Conor McCarthy
db0d51675c vkd3d-shader/spirv: Emit descriptor offset loads in the function entry block. 
Ensures they are loaded only once per function independent of the
control flow graph.
 2024-01-17 22:28:29 +01:00
Henri Verbeet
68b898fcb6 vkd3d-shader/tpf: Store the "precise" mask as a uint32_t in shader_sm4_read_instruction(). 2024-01-15 19:58:22 +01:00
Henri Verbeet
ad2af68d2a vkd3d-shader/tpf: Store the "recognized_bits" mask as a uint32_t in shader_sm4_read_instruction_modifier(). 2024-01-15 19:58:21 +01:00
Henri Verbeet
b8903f5526 vkd3d-shader/tpf: Store the current token as a uint32_t in shader_sm4_read_dst_param(). 2024-01-15 19:58:20 +01:00
Henri Verbeet
fd854bc0c0 vkd3d-shader/tpf: Store the current token as a uint32_t in shader_sm4_read_src_param(). 2024-01-15 19:58:19 +01:00
Henri Verbeet
c5facd4e03 vkd3d-shader/tpf: Store the "addressing" token as a uint32_t in shader_sm4_read_param(). 2024-01-15 19:58:18 +01:00
Henri Verbeet
b1c538e0fe vkd3d-shader/tpf: Store the "components" token as a uint32_t in shader_sm4_read_dcl_resource(). 2024-01-15 19:58:17 +01:00
Henri Verbeet
9896394220 vkd3d-shader/tpf: Pass a uint32_t modifier token to shader_sm4_read_instruction_modifier(). 2024-01-15 19:58:15 +01:00
Nikolay Sivov
1a036ddff6 vkd3d-shader/fx: Do not write the same string twice. 2024-01-15 19:57:43 +01:00
Nikolay Sivov
e7d65d39ba vkd3d-shader/fx: Initial support for fx_5_0 output. 2024-01-15 19:57:42 +01:00
Nikolay Sivov
8014c11e88 vkd3d-shader/fx: Write empty passes blocks. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-15 19:57:41 +01:00
Nikolay Sivov
e1dca9b27a vkd3d-shader/hlsl: Add a scope for technique variables. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-15 19:57:39 +01:00
Nikolay Sivov
0a6d842ed1 vkd3d-shader/hlsl: Rename the rule for an optional name. 
Names are optional for both techniques and passes.

Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-15 19:57:37 +01:00
Francisco Casas
43ff28b00b vkd3d-shader/hlsl: Emit fixmes on non-constant vector addressing. 
Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=56162

Storing to a vector component using a non-constant index is not allowed
on profiles lower than 6.0. Unless this happens inside a loop that can be
unrolled, which we are not doing yet.

For this reason, a validate_nonconstant_vector_store_derefs pass is
added to detect these cases.

Ideally we would want to emit an hlsl_error on this pass, but before
implementing loop unrolling, we could reach this point on valid HLSL.

Also, as pointed out by Nikolay in the mentioned bug, currently
new_offset_from_path_index() fails an assertion when this happens,
because it expects an hlsl_ir_constant, so a check is added.
It also felt correct to emit an hlsl_fixme there, despite the
redundancy.
 2024-01-15 19:57:12 +01:00
Giovanni Mascellani
b0c8a47f9d vkd3d-shader/ir: Check that SSA registers are used validly. 
Specifically, they are assigned only once and only assigned components
are used.

Right now we don't check that the assignment dominates all usages.
 2024-01-15 19:57:01 +01:00
Giovanni Mascellani
26bebe8f91 vkd3d-shader/ir: Check that SSA registers have consistent dimensions. 2024-01-15 19:57:00 +01:00
Giovanni Mascellani
7503429555 vkd3d-shader/ir: Check that TEMP registers have consistent dimensions. 2024-01-15 19:56:59 +01:00
Giovanni Mascellani
fbd77486de vkd3d-shader/ir: Use vkd3d_free() instead of free(). 2024-01-15 19:56:58 +01:00
Giovanni Mascellani
26c6a87268 vkd3d-shader/ir: Simplify control flow in vsir_validate_register(). 2024-01-15 19:56:56 +01:00
Conor McCarthy
52902b042f vkd3d-shader/spirv: Support vector source param for FIRSTBIT_HI and FIRSTBIT_SHI instructions. 2024-01-15 19:56:35 +01:00
Henri Verbeet
3e2ace8d33 vkd3d-shader/dxbc: Use sizeof(uint32_t) instead of sizeof(DWORD) in calls to require_space(). 2024-01-11 23:05:56 +01:00
Henri Verbeet
69350e1ff0 vkd3d-shader/dxbc: Pass an unsigned int count to shader_parse_root_parameters1(). 2024-01-11 23:05:54 +01:00
Henri Verbeet
04acc52496 vkd3d-shader/dxbc: Pass a size_t offset to shader_get_string(). 2024-01-11 23:05:52 +01:00
Conor McCarthy
ac9b14599f vkd3d-shader/dxil: Avoid null dereference on failure to find function pointer type. 
Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=55684
 2024-01-11 23:05:17 +01:00
Giovanni Mascellani
78d95889bd vkd3d-shader: Make *src and *dst mutable in vkd3d_shader_instruction. 
They were originally made const because no optimization/normalization
pass existed. Now having to cast away const all the time is becoming
more and more burdening.
 2024-01-11 23:05:11 +01:00
Henri Verbeet
fd8a0d7fb6 vkd3d-shader/spirv: Pass a uint32_t write mask to spirv_compiler_emit_neg(). 2024-01-11 23:05:03 +01:00
Henri Verbeet
b4da553d28 vkd3d-shader/spirv: Pass a uint32_t write mask to spirv_compiler_emit_abs(). 2024-01-11 23:05:02 +01:00
Henri Verbeet
97acca715e vkd3d-shader/spirv: Pass a uin32_t write mask to spirv_compiler_emit_load_src(). 2024-01-11 23:05:01 +01:00
Henri Verbeet
5c2d0f42b5 vkd3d-shader/spirv: Pass a uint32_t write mask to vkd3d_symbol_set_register_info(). 2024-01-11 23:05:00 +01:00
Henri Verbeet
9dd5b2840f vkd3d-shader: Recognise DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS in shader_validate_descriptor_range1(). 2024-01-11 23:04:54 +01:00
Nikolay Sivov
a0207436f2 vkd3d-shader/tpf: Add initial support for writing fx_4_0/fx_4_1 binaries. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-11 23:04:48 +01:00
Nikolay Sivov
9494b72224 vkd3d-shader: Add separate binary target type for effects. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-11 23:04:48 +01:00
Nikolay Sivov
e527d7c1e7 vkd3d-shader/hlsl: Handle effect group statement. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-11 23:04:46 +01:00
Nikolay Sivov
f7a02a5da2 vkd3d-shader/hlsl: Add variables for techniques. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-11 23:04:45 +01:00
Nikolay Sivov
8494342fa0 vkd3d-shader/hlsl: Rename rule for top-level techniques. 
Only technique10 and technique11 types could be nested in groups.

Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-11 23:04:43 +01:00
Nikolay Sivov
c3af1f9989 vkd3d-shader/hlsl: Add 'fxgroup' token. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2024-01-11 23:04:42 +01:00
Giovanni Mascellani
017f86aaaf vkd3d-shader/d3d-asm: Guess a sensible data type for literals. 
When the typing information is not reliable.
 2024-01-11 23:04:34 +01:00
Henri Verbeet
3344c4e93d vkd3d-shader/hlsl: Store modifier flags as a uint32_t. 2024-01-08 21:45:26 +01:00
Henri Verbeet
fafe2a1dba vkd3d-shader/hlsl: Store swizzles as a uint32_t. 2024-01-08 21:45:24 +01:00
Giovanni Mascellani
7f9803620f vkd3d-shader/spirv: Specify behavior for bit field instructions. 
Bit field instructions in SPIR-V do not specify what happens when
offset + count exceeds the type bit width. After this commit we
refine the emitted code's behavior to match TPF.

This fixes a few failures on MoltenVK.
 2024-01-08 21:44:52 +01:00
Henri Verbeet
5b9a0dfaea vkd3d-shader/ir: Store destination parameter shifts as an unsigned int. 2024-01-04 22:23:54 +01:00
Henri Verbeet
4b5d3a078b vkd3d-shader/ir: Store destination parameter modifier flags as a uint32_t. 2024-01-04 22:23:52 +01:00
Henri Verbeet
60842b7181 vkd3d-shader/ir: Store source parameter swizzles as a uint32_t. 2024-01-04 22:23:51 +01:00
Henri Verbeet
9f4ca3bc9c vkd3d-shader/ir: Store instruction flags as a uint32_t. 2024-01-04 22:23:49 +01:00
Giovanni Mascellani
bd9118cac4 vkd3d-shader/ir: Validate destination write masks depending on the dimension. 2024-01-04 22:23:25 +01:00
Giovanni Mascellani
15e7711786 vkd3d-shader/ir: Validate source swizzles depending on the dimension. 2024-01-04 22:23:24 +01:00
Giovanni Mascellani
e91da41dea vkd3d-shader/ir: Validate SSA registers. 2024-01-04 22:23:23 +01:00
Giovanni Mascellani
e29ae1550c vkd3d-shader/dxil: Create constant buffer registers with dimension vec4. 2024-01-04 22:23:21 +01:00
Giovanni Mascellani
df2ae56de8 vkd3d-shader/d3dbc: Override the write mask when the destination is not vec4. 2024-01-04 22:23:20 +01:00
Zebediah Figura
1ce7e3d8b1 vkd3d-shader/d3dbc: Assign unique register indices for VKD3DSPR_RASTOUT. 2024-01-04 22:23:09 +01:00
Zebediah Figura
3f52fda8ad vkd3d-shader: Lower shader model 1/2 inter-stage I/O to a flat array. 
An alternative is that we stash the reg_type in the signature, but this seems
far simpler for the backend to deal with.
 2024-01-04 22:23:07 +01:00
Giovanni Mascellani
3bafee344d vkd3d-shader/dxil: Use vkd3d_shader_parser_error() for error reporting when available. 2024-01-03 22:38:26 +01:00
Giovanni Mascellani
a02cd1cf64 vkd3d-shader/dxil: Do not use the parser before it is initialized. 2024-01-03 22:38:24 +01:00
Conor McCarthy
111818eabb vkd3d-shader/dxil: Pre-allocate instruction space for globals in sm6_parser_globals_init(). 
For simplicity, declaration handlers assume instruction allocation will
not fail.
 2024-01-03 22:38:21 +01:00
Conor McCarthy
8aa6e2228e vkd3d-shader/dxil: Count global variables in dxil_block_compute_module_decl_count(). 2024-01-03 22:38:19 +01:00
Henri Verbeet
ed4f3f3272 vkd3d-shader/ir: Rename the "immconst_double" field of struct vkd3d_shader_register to "immconst_f64". 2024-01-03 22:37:49 +01:00
Henri Verbeet
7f94fda05c vkd3d-shader/ir: Rename the "immconst_uint64" field of struct vkd3d_shader_register to "immconst_u64". 2024-01-03 22:37:43 +01:00
Henri Verbeet
05a542ba00 vkd3d-shader/ir: Rename the "immconst_float" field of struct vkd3d_shader_register to "immconst_f32". 2024-01-03 22:37:41 +01:00
Henri Verbeet
e33d3b3954 vkd3d-shader/ir: Rename the "immconst_uint" field of struct vkd3d_shader_register to "immconst_u32". 
For consistency with the rest of vkd3d-shader; e.g. put_u32() and
read_u32().
 2024-01-03 22:37:39 +01:00
Conor McCarthy
78343dcf87 vkd3d-shader/spirv: Decorate non-float32 non-built-in pixel shader inputs as Flat. 
As per VUID-StandaloneSpirv-Flat-04744. Not strictly a regression, but
revealed by 66cb2815f because it declares unused inputs.
 2024-01-02 23:03:59 +01:00
Conor McCarthy
812f01c2e2 vkd3d-shader/spirv: Handle ITOI and UTOU in spirv_compiler_map_alu_instruction(). 
These instructions perform integer casts to/from 64 bits.
 2024-01-02 23:03:07 +01:00
Conor McCarthy
1eaa7d1dbe vkd3d-shader/spirv: Support UINT64 source in spirv_compiler_emit_bool_cast(). 2024-01-02 23:03:06 +01:00
Conor McCarthy
99924d913b vkd3d-shader/spirv: Support 64-bit sources in spirv_compiler_emit_int_div(). 2024-01-02 23:03:05 +01:00
Conor McCarthy
13459a55f1 vkd3d-shader/spirv: Introduce a UINT64 component type. 2024-01-02 23:03:04 +01:00
Conor McCarthy
fe44873979 vkd3d-shader/spirv: Introduce a data_type_is_64_bit() helper function. 2024-01-02 23:03:03 +01:00
Conor McCarthy
511c66d595 vkd3d-shader/spirv: Use data_type_is_integer() in spirv_compiler_emit_neg(). 2024-01-02 23:03:02 +01:00
Henri Verbeet
f96a791807 vkd3d-shader/ir: Pass a uint32_t swizzle to vkd3d_swizzle_get_component64(). 2023-12-14 23:19:51 +01:00
Henri Verbeet
8a1de71fb1 vkd3d-shader/ir: Pass a uint32_t swizzle to vkd3d_swizzle_get_component(). 2023-12-14 23:19:49 +01:00
Zebediah Figura
4ff389854c vkd3d-shader: Allow compiling d3d bytecode to SPIR-V. 2023-12-14 23:19:31 +01:00
Zebediah Figura
2bc40385d9 vkd3d-shader: Do not scan DCL instructions which do not declare resources. 2023-12-14 23:19:28 +01:00
Zebediah Figura
8af47a96ea vkd3d-shader: Do not scan the shader in vkd3d_shader_parser_compile() for assembly targets. 2023-12-14 23:19:28 +01:00
Henri Verbeet
21491d1bbb vkd3d-shader/ir: Pass a uint32_t write mask to vkd3d_write_mask_32_from_64(). 2023-12-13 22:33:07 +01:00
Henri Verbeet
3759186193 vkd3d-shader/ir: Pass a uint32_t write mask to vkd3d_write_mask_64_from_32(). 2023-12-13 22:33:06 +01:00
Henri Verbeet
713adaa56a vkd3d-shader/ir: Pass a uint32_t write mask to vkd3d_write_mask_component_count(). 2023-12-13 22:33:04 +01:00
Henri Verbeet
e1aa12f94b vkd3d-shader/ir: Pass a uint32_t write mask to vkd3d_write_mask_get_component_idx(). 2023-12-13 22:33:03 +01:00
Giovanni Mascellani
ec4986e9e2 vkd3d-shader/spirv: Honor force_validation after emitting SPIR-V code. 2023-12-13 22:32:25 +01:00
Giovanni Mascellani
1015cc952e vkd3d-shader/d3d-asm: Add an "internal" mode for the ASM dumper. 
The new mode exposes more details about what's going on inside the VSIR
code and it's meant to ease development and debugging.
 2023-12-12 23:16:26 +01:00
Giovanni Mascellani
e7fdf2e97f vkd3d-shader/d3d-asm: Dump unknown types as "<unknown>". 
In analogy with "<continued>" and "<unused>".
 2023-12-12 23:16:24 +01:00
Giovanni Mascellani
1caaf90ee2 vkd3d-shader/d3d-asm: Dump recently added types. 2023-12-12 23:16:23 +01:00
Giovanni Mascellani
4b6e596740 vkd3d-shader/d3d-asm: Write a single type in shader_dump_data_type(). 2023-12-12 23:16:22 +01:00
Giovanni Mascellani
bd50f15d31 vkd3d-shader/d3d-asm: Indent on IFC. 2023-12-12 23:16:21 +01:00
Conor McCarthy
cdb9eecfd1 vkd3d-shader/spirv: Introduce a compiler feature flag for int64 capability. 2023-12-12 22:50:53 +01:00
Conor McCarthy
0610867334 vkd3d-shader/spirv: Emit an error if 64-bit integers are used. 2023-12-12 22:50:48 +01:00
Conor McCarthy
1929432559 vkd3d-shader: Introduce an instruction flag to suppress masking of bitwise shift counts. 
DXIL does not use implicit masking of shift counts.
 2023-12-12 22:50:46 +01:00
Fabian Maurer
9cb4372378 vkd3d-shader/dxil: Check null pointer before it is dereferenced (Coverity). 2023-12-11 23:18:58 +01:00
Conor McCarthy
2037daae32 vkd3d-shader/spirv: Bitcast if necessary in the spirv_compiler_emit_mov() general implementation. 
In SM 6, this is needed when storing an asfloat() or asuint() result in
an indexable temp, because dxc performs the bitcast by casting the
destination pointer.
 2023-12-11 23:18:52 +01:00
Conor McCarthy
3db7c2a62d vkd3d-shader/dxil: Implement the DXIL STORE instruction. 2023-12-11 23:18:51 +01:00
Conor McCarthy
2d5f2bf7a4 vkd3d-shader/dxil: Implement the DXIL ALLOCA instruction. 2023-12-11 23:18:50 +01:00
Zebediah Figura
d49bccea9a vkd3d-shader/dxil: No longer synthesize DCL instructions. 2023-12-11 23:18:45 +01:00
Zebediah Figura
66cb2815f0 vkd3d-shader/spirv: Declare I/O registers from the signature. 
Instead of parsing DCL instructions.

This allows sm1 to work without further effort, and simplifies sm6 code.
 2023-12-11 23:18:44 +01:00
Zebediah Figura
75348dff12 vkd3d-shader/dxil: Map SEMANTIC_KIND_TARGET to VKD3D_SHADER_SV_TARGET. 2023-12-11 23:18:43 +01:00
Zebediah Figura
cabf9996f9 vkd3d-shader/tpf: Do not uninvert used masks for domain shader patch constants. 2023-12-11 23:18:42 +01:00
Zebediah Figura
8876030590 vkd3d-shader/spirv: Do not use the output_info array for patch constants. 2023-12-11 23:18:40 +01:00
Conor McCarthy
45679a966c vkd3d-shader/ir: Pass a local copy of location to control_point_normaliser_emit_hs_input(). 2023-12-07 21:57:49 +01:00
Zebediah Figura
28f32349f4 vkd3d-shader: Add a helper to search the scan descriptor info. 
Avoid shadowing "info" in vkd3d_shader_scan_combined_sampler_declaration().
 2023-12-07 21:57:34 +01:00
Zebediah Figura
dfea1abbd8 vkd3d-shader/hlsl: Avoid shadowing "jump" in normalize_switch_cases(). 2023-12-07 21:57:33 +01:00
Zebediah Figura
98a02ceffb vkd3d-shader/hlsl: Avoid shadowing "load" in intrinsic_tex(). 2023-12-07 21:57:31 +01:00
Zebediah Figura
a102e99897 vkd3d-shader/hlsl: Avoid shadowing "block" in resolve_loop_continue(). 2023-12-07 21:57:30 +01:00
Zebediah Figura
ca8492c855 vkd3d-shader/d3dbc: Avoid shadowing "instr" in write_sm1_jump(). 2023-12-07 21:57:28 +01:00
Zebediah Figura
46e135f6a7 vkd3d-shader/hlsl: Avoid shadowing "load" in lower_index_loads(). 
Found with -Wshadow.
 2023-12-07 21:57:16 +01:00
Conor McCarthy
a4a1b4c557 vkd3d-shader/dxil: Set the result register data type for nop casts. 
Casts from minimum precision types are emitted as nop, but the result
value type must be set to the cast result type.
 2023-12-07 21:57:08 +01:00
Conor McCarthy
1630fd9a3c vkd3d-shader/dxil: Apply metadata attachments to instructions. 
These are apparently only used for 'dx.op' intrinsics, because the
instructions based on native LLVM ones have their own way to apply
attributes.
 2023-12-07 21:57:00 +01:00
Conor McCarthy
a33a9127ca vkd3d-shader/dxil: Implement DX intrinsic Unary. 2023-12-07 21:56:53 +01:00
Conor McCarthy
cc5e703802 vkd3d-shader/dxil: Emit constant global arrays as immediate constant buffers. 2023-12-07 21:56:47 +01:00
Conor McCarthy
cb88844a3d vkd3d-shader: Add a register index to struct vkd3d_shader_immediate_constant_buffer. 2023-12-07 21:56:47 +01:00
Conor McCarthy
ef940cb778 vkd3d-shader/spirv: Support declared component type and count in immediate constant buffers. 2023-12-07 21:56:45 +01:00
Conor McCarthy
16cb6fdbad vkd3d-shader/spirv: Support constant initialisers in indexable temps. 2023-12-07 21:56:44 +01:00
Conor McCarthy
ffae57eb8d vkd3d-shader/dxil: Support null constant arrays. 2023-12-07 21:56:43 +01:00
Conor McCarthy
69c3946c85 vkd3d-shader/spirv: Support declared component type and count in indexable temps. 2023-12-07 21:56:41 +01:00
Henri Verbeet
0c33f82f72 Release 1.10. 2023-12-06 15:31:21 +01:00
Conor McCarthy
9fcc904834 vkd3d-shader/spirv: Always emit clip/cull builtins as an array. 
Clip/cull distance can appear as input in pixel shaders, and the
array size must not be forced to zero.
 2023-12-06 15:31:20 +01:00
Conor McCarthy
b5c067b41a vkd3d-shader/ir: Do not merge signature elements which have different interpolation modes. 
Regression in signature normalisation, however the old code was not
correct either because it would apply the interpolation mode to all
components. Found in an Assassin's Creed: Valhalla shader.
 2023-12-06 15:31:18 +01:00
Conor McCarthy
b4d03c0221 vkd3d-shader/spirv: Do not emit a fixme for SV_TARGET in vkd3d_get_spirv_builtin(). 2023-12-04 22:22:55 +01:00
Conor McCarthy
f11e1461aa vkd3d-shader/spirv: Do not emit a fixme for SV_TARGET in get_spirv_builtin_for_sysval(). 2023-12-04 22:22:54 +01:00
Francisco Casas
736f3ae2df vkd3d-shader/hlsl: Use values at the time of the swizzle's load in copy-propagation. 
This preempts us from replacing a swizzle incorrectly, as in the
following example:

    1: A.x = 1.0
    2: A
    3: A.x = 2.0
    4: @2.x

were @4 ends up being 2.0 instead of 1.0, because that's the value stored in
A.x at time 4, and we should be querying it at time 2.

This also helps us to avoid replacing a swizzle with itself in copy-prop
which can result in infinite loops, as with the included tests this commit.

Consider the following sequence of instructions:

    1 : A
    2 : B = @1
    3 : B
    4 : A = @3
    5 : @1.x

Current copy-prop would replace 5 so it points to @3 now:

    1 : A
    2 : B = @1
    3 : B
    4 : A = @3
    5 : @3.x

But in the next iteration it would make it point back to @1, keeping it
spinning infinitively.

The solution is to index the instructions and don't replace the swizzle
if the new load happens after the current load.
 2023-11-29 22:53:24 +01:00
Francisco Casas
d877b877b3 vkd3d-shader/hlsl: Record trace of stored values in copy-propagation. 
Instead of only storing the value that each variable's component has at
the moment of the instruction currently handled by copy-prop, we store
the trace of all the historic values with their timestamps, i.e. the
instruction index on which the value was stored.

This would allow us to query the value that the variable had at the time
of execution of previous instructions.
 2023-11-29 22:53:21 +01:00
Francisco Casas
539294daea vkd3d-shader/hlsl: Move index_instructions() up. 2023-11-29 22:53:19 +01:00
Giovanni Mascellani
a52604da8c vkd3d-shader/dxil: Declare IO registers as VEC4. 
Otherwise, for instance, their write masks and swizzles are not written
in the D3D ASM dump.
 2023-11-28 21:49:18 +01:00
Nikolay Sivov
6a4a9a4518 vkd3d-shader/hlsl: Handle 'linear centroid' modifier. 2023-11-28 00:10:12 +01:00
Zebediah Figura
10957bebbf vkd3d-shader/tpf: Remove an unnecessary local variable declaration. 
Found with -Wshadow.
 2023-11-28 00:09:56 +01:00
Zebediah Figura
2d1825bb89 vkd3d-shader/hlsl: Remove an unnecessary local variable in copy_propagation_get_value(). 
Found with -Wshadow.
 2023-11-28 00:09:53 +01:00
Jacek Caban
85f21f197c vkd3d-shader: Avoid implicit enum pointer casts in allocate_semantic_register. 2023-11-28 00:09:29 +01:00
Jacek Caban
1edbc05745 vkd3d-shader: Use unsigned int type for tags passed to sm6_metadata_get_uint_value. 2023-11-28 00:09:29 +01:00
Francisco Casas
4e1bf5e163 vkd3d-shader/hlsl: Discern between signed and unsigned ints when parsing. 2023-11-22 22:08:05 +01:00
Francisco Casas
9a8f6e0edb vkd3d-shader/hlsl: Parse integers with the 'u' postfix. 2023-11-22 22:08:04 +01:00
Conor McCarthy
eb05e434ff vkd3d-shader/dxil: Implement the DXIL LOAD instruction. 2023-11-22 22:07:59 +01:00
Conor McCarthy
59730ecfd8 vkd3d-shader/dxil: Implement the DXIL GEP instruction. 2023-11-22 22:07:58 +01:00
Conor McCarthy
a0f5d70792 vkd3d-shader/dxil: Support global variable initialisers. 2023-11-22 22:07:57 +01:00
Conor McCarthy
f2a656b876 vkd3d-shader/dxil: Introduce a value type for immediate constant buffers. 2023-11-22 22:07:56 +01:00
Conor McCarthy
85d5f83fb7 vkd3d-shader/dxil: Implement default address space global variables. 2023-11-22 22:07:54 +01:00
Conor McCarthy
920657e7ee vkd3d-shader: Delete unused struct list from struct vkd3d_shader_indexable_temp. 2023-11-22 22:07:52 +01:00
Henri Verbeet
ae4341b565 vkd3d-shader/ir: Use location information from the instruction in vkd3d_shader_scan_instruction(). 2023-11-21 22:41:58 +01:00
Henri Verbeet
01dad41862 vkd3d-shader/ir: Skip recording combined resource/sampler information for dynamically indexed descriptor arrays. 
And output a warning instead.
 2023-11-21 22:41:57 +01:00
Henri Verbeet
5b82afb83f vkd3d-shader/ir: Decorate vkd3d_shader_scan_error() with VKD3D_PRINTF_FUNC. 2023-11-21 22:41:55 +01:00
Jacek Caban
078cf6a240 vkd3d-shader/dxbc: Use return type to return result from read_u32 and read_float. 
Avoid implicit casts from enum pointers.
 2023-11-20 22:07:45 +01:00
Giovanni Mascellani
b1123ed35f vkd3d-shader/ir: Correctly compute the TEMP count after hull shader flattening. 
The previous computation was incorrect because the count was taken
after resetting it to zero (as part of setting the instruction to NOP).
 2023-11-20 22:07:41 +01:00
Giovanni Mascellani
5cb17cfd1c vkd3d-shader/ir: Validate IFC instructions. 2023-11-20 22:07:36 +01:00
Giovanni Mascellani
849a8f3add vkd3d-shader/ir: Expect two sources for LOOP in SM1-3. 2023-11-20 22:07:35 +01:00
Henri Verbeet
73c563ffb7 vkd3d-shader/d3dbc: Adjust the token count for DEF and DEFI instructions in shader_sm1_skip_opcode(). 
This was broken by commit e390bc35e2c9b0a2110370f916033eea2366317e; that
commit fixed the source count for these instructions, but didn't adjust
shader_sm1_skip_opcode(). Note that this only affects shader model 1;
later versions have a token count embedded in the initial opcode token.
 2023-11-20 22:07:29 +01:00
Nikolay Sivov
e55b6a7fa1 vkd3d-shader/hlsl: Add constants to the block for log()/log10() builtins. 2023-11-20 22:07:24 +01:00
Akihiro Sagawa
aed2d142cf vkd3d-shader/hlsl: Add degrees() function. 2023-11-20 22:07:19 +01:00
Akihiro Sagawa
e493627130 vkd3d-shader/hlsl: Add radians() function. 2023-11-20 22:07:17 +01:00
Nikolay Sivov
88caf87789 vkd3d-shader/hlsl: Add a helper to check for a numeric type. 2023-11-15 21:48:49 +01:00
Conor McCarthy
fb588b8d1a vkd3d-shader/spirv: Avoid invalid bool-to-bool conversion in spirv_compiler_emit_movc(). 
Shaders parsed from DXIL contain a bool condition register, so calling
spirv_compiler_emit_int_to_bool() results in an invalid bool/uint
comparison.
 2023-11-15 21:48:36 +01:00
Conor McCarthy
3c4631a4d4 vkd3d-shader/dxil: Implement the DXIL VSELECT instruction. 2023-11-15 21:48:35 +01:00
Conor McCarthy
08b8730866 vkd3d-shader/spirv: Return an error if an invalid handler is encountered. 
Prevents return of an invalid SPIR-V module.
 2023-11-15 21:48:31 +01:00
Conor McCarthy
408f67c69c vkd3d-shader/dxil: Handle missing flags as zero for CMP2. 
The flag operand is omitted if IEEE strictness is specified.
 2023-11-14 23:06:43 +01:00
Conor McCarthy
f1e9f40061 vkd3d-shader/dxil: Handle missing flags as zero for BINOP. 
The flag operand is omitted if IEEE strictness is specified.
 2023-11-14 23:06:41 +01:00
Henri Verbeet
9de793f180 vkd3d-shader: Implement scanning combined resource/sampler information. 2023-11-13 23:19:23 +01:00
Nikolay Sivov
d190fdf8c5 vkd3d-shader/dxil: Fully initialize instruction data in sm6_parser_emit_extractval(). 
Noticed after test runner started crashing when tracing is enabled.

Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-13 23:19:18 +01:00
Nikolay Sivov
3203485a7c vkd3d-shader: Fix some spelling mistakes. 2023-11-13 23:19:15 +01:00
Henri Verbeet
215a2c4ede vkd3d-shader/ir: Introduce vsir_register_is_descriptor(). 2023-11-13 23:19:10 +01:00
Conor McCarthy
22960753e9 vkd3d-shader/spirv: Introduce orderedness to comparison instructions. 2023-11-10 20:23:51 +01:00
Conor McCarthy
d3b90cc877 vkd3d-shader/dxil: Implement the DXIL CMP2 instruction. 2023-11-10 20:23:50 +01:00
Conor McCarthy
1dd141535c vkd3d-shader/spirv: Support bool dst register in spirv_compiler_emit_comparison_instruction(). 2023-11-10 20:23:48 +01:00
Nikolay Sivov
418c177a1b vkd3d-shader/hlsl: Implement texCUBEproj(). 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-10 20:23:44 +01:00
Nikolay Sivov
81ff57e07c vkd3d-shader/hlsl: Implement tex3Dproj(). 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-10 20:23:43 +01:00
Nikolay Sivov
dd6a9135f4 vkd3d-shader/hlsl: Implement tex2Dproj(). 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-10 20:23:41 +01:00
Giovanni Mascellani
0c5c18bdce vkd3d-shader/ir: Validate index count for IMMCONST64 registers. 2023-11-09 21:15:51 +01:00
Giovanni Mascellani
b74470b9d2 vkd3d-shader/ir: Validate index count for IMMCONST registers. 2023-11-09 21:15:49 +01:00
Giovanni Mascellani
c867682982 vkd3d-shader/ir: Validate index count for NULL registers. 2023-11-09 21:15:47 +01:00
Giovanni Mascellani
12fcb8dcc6 vkd3d-shader/ir: Validate register indices. 2023-11-09 21:15:44 +01:00
Giovanni Mascellani
b7aeb5dd70 vkd3d-shader/ir: Use vsir_register_init() to initialize a register. 2023-11-09 21:15:42 +01:00
Giovanni Mascellani
a869069a48 vkd3d-shader/ir: Validate the TEMP register indices in each HS phase. 2023-11-09 21:15:40 +01:00
Giovanni Mascellani
0f4bda9c9d vkd3d-shader/ir: Keep track of hull shader phases. 2023-11-09 21:15:38 +01:00
Conor McCarthy
5768c019c1 vkd3d-shader/ir: Check the handler before changing it to NOP in remove_dead_code(). 2023-11-09 21:15:29 +01:00
Zebediah Figura
ade8899456 vkd3d-shader/hlsl: Use hlsl_types_are_equal() in func_decl_matches(). 
Besides reusing code, this now handles UAV types correctly.
 2023-11-09 21:15:21 +01:00
Zebediah Figura
8f041fbe6f vkd3d-shader/hlsl: Return bool from compare_function_decl(). 2023-11-09 21:15:19 +01:00
Zebediah Figura
fef118555c vkd3d-shader/hlsl: Do not prioritize an exact match when looking up functions. 
Native does not always do this. For example, functions whose parameters are
float and float1 always result in an "ambiguous function call" error.

This does not fix any tests, because the relevant tests previously (incorrectly)
succeeded, and now fail with:

E5017: Aborting due to not yet implemented feature: Prioritize between multiple compatible function overloads.

when they should simply fail.
 2023-11-09 21:15:17 +01:00
Zebediah Figura
514d179b70 vkd3d-shader/hlsl: Do not consider scalars and 1-dimensional vectors to be equivalent in function parameters. 2023-11-09 21:15:14 +01:00
Zebediah Figura
b1c2852cd7 vkd3d-shader/hlsl: Store function overloads in a list. 
The choice to store them in an rbtree was made early on. It does not seem likely
that HLSL programs would define many overloads for any of their functions, but I
suspect the idea was rather that intrinsics would be defined as plain
hlsl_ir_function_decl structures [cf. 447463e590]
and that some intrinsics that could operate on any type would therefore need
many overrides.

This is not how we deal with intrinsics, however. When the first intrinsics were
implemented I made the choice disregard this intended design, and instead match
and convert their types manually, in C. Nothing that has happened in the time
since has led me to question that choice, and in fact, the flexibility with
which we must accommodate functions has led me to believe that matching in this
way was definitely the right choice. The main other designs I see would have
been:

* define each intrinsic variant separately using existing HLSL types. Besides
  efficiency concerns (i.e. this would take more space in memory, and would take
  longer to generate each variant), the normal type-matching rules don't really
  apply to intrinsics.

  [For example: elementwise intrinsics like abs() return the same type as the
  input, including preserving the distinction between float and float1. It is
  legal to define separate HLSL overloads taking float and float1, but trying to
  invoke these functions yields an "ambiguous function call" error.]

* introduce new (semi-)generic types. This is far more code and ends up acting
  like our current scheme (with helpers) in a slightly more complex form.

So I think we can go ahead and rip out this vestige of the original design for
intrinsics.

As for why to change it: rbtrees are simply more complex to deal with, and it
seems unlikely to me that the difference is going to matter. I do not expect any
program to define large quantities of intrinsics; linked list search should be
good enough.
 2023-11-09 21:15:11 +01:00
Zebediah Figura
2b59a759d5 vkd3d-shader/hlsl: Rename hlsl_get_func_decl() to hlsl_get_first_func_decl(). 2023-11-09 21:15:09 +01:00
Zebediah Figura
011e31f624 vkd3d-shader/spirv: Remove no longer used private_output_variable_array_idx array. 2023-11-09 21:15:01 +01:00
Zebediah Figura
8513f567fa vkd3d-shader/spirv: Look up builtins by vkd3d_shader_sysval_semantic. 
Instead of by vkd3d_shader_input_sysval_semantic.
 2023-11-09 21:14:57 +01:00
Zebediah Figura
87cb66dd43 vkd3d-shader/spirv: Simplify spirv_compiler_emit_dcl_input(). 2023-11-09 21:14:55 +01:00
Zebediah Figura
c7a7d9a18c vkd3d-shader/ir: Normalize all I/O registers to INPUT/OUTPUT/PATCHCONST. 
Specifically, map COLOROUT to OUTPUT, and map INCONTROLPOINT to INPUT for domain
shaders as well as hull shaders.

Obscure the non-existent differences from the view of the backend.
 2023-11-09 21:14:52 +01:00
Zebediah Figura
133e313800 vkd3d-shader/dxil: Do not use COLOROUT for PS outputs. 
sm4 does not use this; only sm1 does. In following patches we will normalize it
to OUTPUT.
 2023-11-09 21:14:49 +01:00
Conor McCarthy
90d178bf12 vkd3d-shader/dxil: Implement the DXIL CAST instruction. 2023-11-09 21:14:42 +01:00
Conor McCarthy
bd77cbb33f vkd3d-shader/spirv: Support double in spirv_compiler_emit_ftou(). 2023-11-09 21:14:40 +01:00
Conor McCarthy
92d546f3a2 vkd3d-shader/spirv: Support double in spirv_compiler_emit_ftoi(). 2023-11-09 21:14:37 +01:00
Conor McCarthy
169210558d vkd3d-shader/spirv: Handle unsigned result in spirv_compiler_emit_ftoi(). 2023-11-09 21:14:35 +01:00
Conor McCarthy
58ffb5d181 vkd3d-shader/spirv: Introduce integer width cast instructions. 
ITOI and UTOU may cast from a bool to a 32-bit integer. Cast to a 64-bit
integer from a smaller type will be added later.
 2023-11-09 21:14:32 +01:00
Conor McCarthy
7de4ac2e48 vkd3d-shader/spirv: Support bool cast in spirv_compiler_emit_alu_instruction(). 2023-11-09 21:14:30 +01:00
Conor McCarthy
5b87d6419a vkd3d-shader/spirv: Support bool logic ops in spirv_compiler_emit_alu_instruction(). 2023-11-09 21:14:27 +01:00
Conor McCarthy
b43dab50c1 vkd3d-shader/spirv: Support bitcast in spirv_compiler_emit_load_ssa_reg(). 2023-11-09 21:14:25 +01:00
Henri Verbeet
e7eec3e023 vkd3d-shader/spirv: Allow the origin of fragment coordinates to be specified. 
We typically want to use lower-left in OpenGL environments when rendering to
FBOs.
 2023-11-09 21:14:12 +01:00
Nikolay Sivov
4778d051df vkd3d-shader: Add constant folding for 'floor'. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-08 22:49:40 +01:00
Nikolay Sivov
634ec96b52 vkd3d-shader: Add a missing entry to instruction debug print helper. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-08 22:49:40 +01:00
Nikolay Sivov
955932fb55 vkd3d-shader: Add constant folding for 'ceil'. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-08 22:49:40 +01:00
Nikolay Sivov
9a70ae5b6a vkd3d-shader: Add support for floor() on SM1-3. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-08 22:49:40 +01:00
Nikolay Sivov
aaef82e680 vkd3d-shader: Add support for ceil() on SM1-3. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-08 22:49:40 +01:00
Nikolay Sivov
494f681bf6 vkd3d-shader/tpf: Add support for ceil(). 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-08 22:49:38 +01:00
Nikolay Sivov
4284b7c522 vkd3d-shader/hlsl: Parse ceil() function. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-08 22:49:37 +01:00
Nikolay Sivov
76e42fbd21 vkd3d-shader/hlsl: Implement ternary operator for SM1. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-08 22:49:31 +01:00
Nikolay Sivov
522a0dfb56 vkd3d-shader/hlsl: Add tex2Dlod() function. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-08 22:49:26 +01:00
Zebediah Figura
852eefc01d vkd3d-shader/ir: Synthesize HS inputs with the register index and write mask of the signature element. 
This pass was written as if to output normalized I/O, but it runs before the I/O
normalization pass.

Fixes: 98b5e2c6e0
 2023-11-07 22:26:53 +01:00
Zebediah Figura
12240efa79 vkd3d-shader/spirv: Use register counts from the signature and shader desc. 2023-11-07 22:26:49 +01:00
Zebediah Figura
0058764f01 vkd3d-shader: Store the control point counts in struct vkd3d_shader_desc. 2023-11-07 22:26:49 +01:00
Zebediah Figura
3ff22ac5af vkd3d-shader/spirv: Use the array sizes for shader phase builtins as well. 2023-11-07 22:26:47 +01:00
Zebediah Figura
f0a6c7de1d vkd3d-shader/hlsl: Record partial allocations in allocate_range(). 2023-11-07 22:26:11 +01:00
Zebediah Figura
c683fc9402 vkd3d-shader/hlsl: Check that a partial register's mask is also available in is_range_available(). 2023-11-07 22:26:10 +01:00
Giovanni Mascellani
7d49f9637a vkd3d-shader/ir: Check that SWITCH blocks are correctly nested. 2023-11-07 22:26:05 +01:00
Giovanni Mascellani
93632fb407 vkd3d-shader/ir: Check that REP blocks are correctly nested. 2023-11-07 22:26:04 +01:00
Giovanni Mascellani
92c36615ed vkd3d-shader/ir: Check that LOOP blocks are correctly nested. 2023-11-07 22:26:03 +01:00
Giovanni Mascellani
2f7d52dba4 vkd3d-shader/ir: Check that IF blocks are correctly nested. 2023-11-07 22:26:01 +01:00
Giovanni Mascellani
0a7e200f89 vkd3d-shader/ir: Do not enfore DCL_TEMPS count for hull shaders. 
Hull shaders have a different temps count for each phase, and the
parser only reports the count for the patch constant phase.
In order to properly check for temps count on hull shaders, we first
need to decode its phases.
 2023-11-07 22:26:00 +01:00
Giovanni Mascellani
ca3f594ae3 vkd3d-shader/ir: Emit an ERR() on validation errors. 2023-11-07 22:25:58 +01:00
Francisco Casas
0ef25ad137 vkd3d-shader/tpf: Support relative addressing for indexable temps in SM4. 
For relative addressing, the vkd3d_shader_registers must point to
another vkd3d_shader_src_param. For now, use the sm4_instruction to save
them, since the only purpose of this struct is to be used as paramter
for write_sm4_instruction.
 2023-11-07 22:25:49 +01:00
Francisco Casas
281796c526 vkd3d-shader/tpf: Move sm4_register_from_node() up. 2023-11-07 22:25:48 +01:00
Francisco Casas
e10d41d799 vkd3d-shader/tpf: Support writing relative addressing indexes. 2023-11-07 22:25:47 +01:00
Francisco Casas
617a20bffc vkd3d-shader/tpf: Write register index addressing. 2023-11-07 22:25:45 +01:00
Francisco Casas
043526a9f7 vkd3d-shader/tpf: Encode dst and src registers using the same function. 
This function will also be required to encode rel_addr registers.
 2023-11-07 22:25:44 +01:00
Henri Verbeet
aa5380f32a vkd3d-shader/tpf: Do not write RDEF constant buffer entries for HLSL_CLASS_OBJECT variables. 
RWBuffer objects would trigger a vkd3d_unreachable() in sm4_base_type().
It would be easy enough to add the required case there, but (manual,
unfortunately) tests show that we aren't supposed to write constant
buffer entries for objects in the first place, as you'd expect.

This particular path ends up being exercised by vkd3d's internal UAV
clear shaders, but unfortunately it looks like our RDEF data may have
more issues; the ability to write tests for it would seem helpful.
 2023-11-06 23:09:47 +01:00
Zebediah Figura
a9f33e8657 vkd3d-shader/hlsl: Consistently use HLSL allocation functions. 2023-11-06 23:09:22 +01:00
Zebediah Figura
b9c164c1c4 vkd3d-shader/hlsl: Sort keywords. 
Done with `LC_ALL=C sort -f`.
 2023-11-06 23:09:20 +01:00
Zebediah Figura
7632365e60 vkd3d-shader/hlsl: Remove C++ comment lexing. 
This is already handled by the preprocessor.
 2023-11-06 23:09:19 +01:00
Zebediah Figura
4cfc7d44ab vkd3d-shader/hlsl: Remove some tokens from the lexer. 
None of these currently have any meaning, and none of these can currently be
parsed as distinct tokens either (i.e. they will generate a syntax error
anyway).
 2023-11-06 23:09:18 +01:00
Francisco Casas
98b5eb474a vkd3d-shader/tpf: Don't pass 0x4 as mask for vec4 constant src registers. 
Co-authored-by: Evan Tang <etang@codeweavers.com>

Evan Tang reported that new fixmes appeared on the shader_runner when
running some of his tests after
f50d0ae2cb.

    vkd3d:652593:fixme:shader_sm4_read_src_param Unhandled mask 0x4.

The change to blame seems to be this added line in
sm4_src_from_constant_value().

    +    src->swizzle = VKD3D_SHADER_NO_SWIZZLE;

On tpf binaries the last 12 bits of each src register in an instruction
specify the swizzle, and there are 5 possible combinations:

    Dimension NONE
    -------- 00

    Dimension SCALAR
    -------- 01

    Dimension VEC4, with a 4 bit writemask:
    ---- xxxx 00 01

    Dimension VEC4, with an 8 bit swizzle:
    xx xx xx xx 01 01

    Dimension VEC4, with a 2bit scalar dimension number:
    ------ xx 10 01

So far, we have only seen src registers use 4 bit writemasks in a
single case: for vec4 constants, and it is always zero.

So we expect this:

    ---- 0000 00 01

Now, I probably wanted to initialize src->swizzle to zero when writing
constants, but VKD3D_SHADER_NO_SWIZZLE is not zero, it is actually the
default swizzle:

    11 10 01 00

And the last 4 bits (0x4) get written in the mask part, which causes
the reader to complain.
 2023-11-06 23:09:10 +01:00
Conor McCarthy
749df8dec2 vkd3d-shader/dxil: Implement the DXIL BINOP instruction. 2023-11-06 23:09:03 +01:00
Conor McCarthy
3e0638148a vkd3d-shader/spirv: Support VKD3D_DATA_UINT in spirv_compiler_emit_neg(). 
The DXIL parser uses unsigned types even if the source code uses signed,
so unsigned values may be negated.
 2023-11-06 23:09:02 +01:00
Conor McCarthy
4905d047bd vkd3d-shader/spirv: Handle the UMUL instruction. 2023-11-06 23:09:01 +01:00
Conor McCarthy
acbc80cba2 vkd3d-shader/spirv: Introduce an IDIV instruction. 2023-11-06 23:09:00 +01:00
Conor McCarthy
c8d3515d8b vkd3d-shader/spirv: Introduce an FREM instruction. 2023-11-06 23:08:58 +01:00
Giovanni Mascellani
0d4aebd2e7 vkd3d-shader: Explicitly cast vkd3d_shader_global_flags to uint64_t. 
On macOS vkd3d_shader_global_flags has underlying type unsigned long,
while uint64_t is defined as unsigned long long. This difference
causes a few warnings to be raised.
 2023-11-06 23:08:37 +01:00
Nikolay Sivov
31346e2cba vkd3d-shader/tpf: Fix used temp registers accounting for dcl_temps. 
Otherwise we always output "dcl_temps 1" even when no temp registers were used.
 2023-11-06 23:08:10 +01:00
Zebediah Figura
f05be8ff12 vkd3d-shader/spirv: No longer handle builtin array size mismatch in spirv_compiler_emit_input(). 
This is taken care of by prior I/O lowering. We no longer need to deal with this here.
 2023-11-06 23:07:59 +01:00
Zebediah Figura
fa23165cc0 vkd3d-shader/spirv: Remove handling of VKD3DSPR_OUTCONTROLPOINT. 
I/O normalization removes this register type.
 2023-11-06 23:07:58 +01:00
Zebediah Figura
b73d2c978d vkd3d-shader/ir: Check for vocp usage during IR normalization. 
The hull shader barrier used for this was broken by I/O normalization, since
vocp is no longer exposed to the spirv backend.

Restore this barrier by checking for vocp during normalization instead.
 2023-11-06 23:07:56 +01:00
Zebediah Figura
8b42f523f2 vkd3d-shader/ir: Pass a vkd3d_shader_parser to instruction_array_normalise_io_registers(). 2023-11-06 23:07:54 +01:00
Conor McCarthy
7419f4e31d vkd3d-shader/dxil: Allow empty struct types. 2023-11-02 18:23:12 +01:00
Nikolay Sivov
dbcc4c4e40 vkd3d-shader/hlsl: Parse empty technique declarations. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-02 18:23:07 +01:00
Nikolay Sivov
53b0101a53 vkd3d-shader/hlsl: Use case-insensitive match for the "technique" keyword. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-02 18:23:06 +01:00
Nikolay Sivov
ea8ff5394c vkd3d-shader/hlsl: Add a keyword for fx_5_0 techniques. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-02 18:23:05 +01:00
Conor McCarthy
7ca6a5452a vkd3d-shader/dxil: Always apply the signature element start column to used_mask. 
The used_mask value loaded from an additional tag/value pair is relative
to the start column.
 2023-11-02 18:22:59 +01:00
Giovanni Mascellani
af72466db1 vkd3d-shader/ir: Validate the index of a TEMP register. 2023-11-02 18:22:52 +01:00
Giovanni Mascellani
4140b87499 vkd3d-shader/ir: Validate the DCL_TEMPS instruction. 2023-11-02 18:22:50 +01:00
Giovanni Mascellani
79fa5fd8bb vkd3d-shader/ir: Validate the register index count. 2023-11-02 18:22:49 +01:00
Giovanni Mascellani
26e4191d4b vkd3d-shader/ir: Validate the register dimension. 2023-11-02 18:22:47 +01:00
Giovanni Mascellani
f3a20be35a vkd3d-shader/ir: Validate the register data type. 2023-11-02 18:22:38 +01:00
Giovanni Mascellani
72d0f765f2 vkd3d-shader/ir: Validate the register precision. 2023-11-02 18:22:37 +01:00
Giovanni Mascellani
f3c1a15a6f vkd3d-shader/dxil: Use vsir_register_init() to initialize registers. 2023-11-02 18:22:35 +01:00
Giovanni Mascellani
2ba8c5771c vkd3d-shader: Deduplicate profile version comparison functions. 2023-11-02 18:22:35 +01:00
Giovanni Mascellani
dd96fe50e2 vkd3d-shader: Dump shaders as soon as possible. 
So that they are dumped even if parsing fails, which is a circumstance
in which one likely wants to see the problematic shader.

The downside of that is that for shader types other than HLSL
the profile is not written any more in the filename. This should
not be a big problem, because in those cases the shader describes
its own type.

When dumping an HLSL shader, the id is brought in front of the profile
in the file name, in order to make it more tab-friendly: when dealing
with a directory full of shaders it's likely that the id determines
the profile, but the other way around.
 2023-11-02 18:22:26 +01:00
Giovanni Mascellani
ab09c0b45b vkd3d-shader: Expose the whole profile when dumping an HLSL shader. 
The profile cannot be reliably devised by analyzing the HLSL code,
so it's useful to have it included in the file name.
 2023-11-02 18:22:24 +01:00
Nikolay Sivov
ecdc3f39d4 vkd3d-shader: Accept 'loop' attribute, on loops. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-01 21:47:49 +01:00
Nikolay Sivov
26784672d8 vkd3d-shader: Check loop [unroll] attribute for conflict with other attributes. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-11-01 21:47:49 +01:00
Conor McCarthy
589670180a vkd3d-shader/dxil: Implement the DXIL EXTRACTVAL instruction. 2023-11-01 21:47:34 +01:00
Conor McCarthy
e899b67bbf vkd3d-shader/spirv: Support scalar swizzle of vector SSA registers. 2023-11-01 21:47:33 +01:00
Conor McCarthy
43b5d73870 vkd3d-shader/dxil: Implement DX instruction CBufferLoadLegacy. 2023-11-01 21:47:32 +01:00
Conor McCarthy
3b1bbe2b0a vkd3d-shader/dxil: Implement DX instruction CreateHandle. 2023-11-01 21:47:30 +01:00
Conor McCarthy
f57d65361a vkd3d-shader/dxil: Replace register_address_init() with register_index_address_init(). 
Makes it much clearer which register index is being written.
 2023-11-01 21:47:29 +01:00
Zebediah Figura
a66acea1b5 vkd3d-shader/spirv: Always use the sysval from the signature. 2023-10-31 21:59:40 +01:00
Zebediah Figura
eef62b95c1 vkd3d-shader/spirv: Use the interpolation mode from the signature. 2023-10-31 21:59:39 +01:00
Zebediah Figura
15b69721de vkd3d-shader/tpf: Set the interpolation mode for signature elements. 2023-10-31 21:59:38 +01:00
Zebediah Figura
6b7834d635 vkd3d-shader/d3dbc: Set the interpolation mode for signature elements. 2023-10-31 21:59:36 +01:00
Zebediah Figura
a668f1ce1c vkd3d-shader: Handle a NULL descriptor info in vkd3d_shader_scan_add_descriptor(). 2023-10-31 21:59:33 +01:00
Francisco Casas
eef2163375 vkd3d-shader/tpf: Declare indexable temps. 
If var->indexable, then the variable is given a unique register number,
regardless of its lifetime.
 2023-10-31 21:59:22 +01:00
Francisco Casas
83c313ecc6 vkd3d-shader/hlsl: Mark vars that require non-constant dereferences. 2023-10-31 21:59:21 +01:00
Francisco Casas
313df300ad vkd3d-shader/hlsl: Rename hlsl_deref.offset to hlsl_deref.rel_offset. 
This field is now analogous to vkd3d_shader_register_index.rel_addr.

Also, it makes sense to rename it now because all the constant part of
the offset is now handled to hlsl_deref.const_offset. Consequently, it
may also be NULL now.
 2023-10-31 21:59:19 +01:00
Francisco Casas
74767beaf6 vkd3d-shader/hlsl: Absorb hlsl_ir_constant deref offsets into const_offset. 2023-10-31 21:59:18 +01:00
Francisco Casas
1520f327e5 vkd3d-shader/hlsl: Express deref->offset in whole registers. 
This is required to use SM4 relative addressing, because it is limited
to whole-register granularity.
 2023-10-31 21:59:16 +01:00
Francisco Casas
61a17643a2 vkd3d-shader/hlsl: Split deref-offset into a node and a constant uint. 
This uint will be used for the following:

- Since SM4's relative addressing (the capability of passing a register
  as an index to another register) only has whole-register granularity,
  we will need to make the offset node express the offset in
  whole-registers and specify the register component in this uint,
  otherwise we would have to add additional / and % operations in the
  output binary.

- If, after we apply constant folding and copy propagation, we determine
  that the offset is a single constant node, we can store all the offset
  in this uint constant, and remove the offset src.

  This allows DCE to remove a good bunch of the nodes previously required
  only for the offset constants, which makes the output more liteweight
  and readable, and simplifies the implementation of relative addressing
  when writing tpf in the following patches.

In dump_deref(), we use "c" to indicate components instead of whole
registers. Since now both the offset node and the offset uint are in
components a lowered deref would look like:

    var[@42c + 2c]

But, once we express the offset node in whole registers we will remove
the "c" from the node part:

    var[@22 + 3c]
 2023-10-31 21:59:14 +01:00
Francisco Casas
81be47c00b vkd3d-shader/hlsl: Introduce hlsl_deref_is_lowered() helper. 
Some functions work with dereferences and need to know if they are
lowered yet.

This can be known checking if deref->offset.node is NULL or
deref->data_type is NULL. I am using the latter since it keeps working
even after the following patches that split deref->offset into
constant and variable parts.
 2023-10-31 21:59:12 +01:00
Francisco Casas
e93568f290 vkd3d-shader/hlsl: Clean-up instruction block for offset node creation. 2023-10-31 21:59:11 +01:00
Nikolay Sivov
bc2a4ee66a vkd3d-shader/tpf: Write out 'switch' statements. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-31 21:59:05 +01:00
Nikolay Sivov
68c14079a6 vkd3d-shader/hlsl: Add a pass to normalize switch cases blocks. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-31 21:59:04 +01:00
Nikolay Sivov
c84d4e3571 vkd3d-shader/hlsl: Add a pass to remove unreachable code. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-31 21:59:03 +01:00
Nikolay Sivov
a4fa323e6c vkd3d-shader/hlsl: Add copy propagation logic for switches. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-31 21:59:02 +01:00
Nikolay Sivov
72623031a2 vkd3d-shader/hlsl: Validate break/continue context. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-31 21:59:01 +01:00
Nikolay Sivov
9a6e4a0c58 vkd3d-shader/hlsl: Check for duplicate case statements. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-31 21:58:59 +01:00
Nikolay Sivov
ec8dfa467f vkd3d-shader/hlsl: Add initial support for parsing 'switch' statements. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-31 21:58:57 +01:00
Conor McCarthy
b7b128595e vkd3d-shader/dxil: Read CBV descriptors. 2023-10-19 23:07:45 +02:00
Conor McCarthy
1e5f91b371 vkd3d-shader: Emit IR CBV declaration sizes in bytes. 
DXIL declares CBV sizes in bytes and they are not aligned to 16 bytes.
 2023-10-19 23:07:43 +02:00
Conor McCarthy
f7525bf0c6 vkd3d-shader/dxil: Validate the descriptor list metadata nodes. 2023-10-19 23:07:42 +02:00
Conor McCarthy
9b64d04ed3 vkd3d-shader/spirv: Align constant buffer sizes to 16 bytes. 
DXIL constant buffer sizes are not aligned to 16 bytes.
 2023-10-19 23:07:40 +02:00
Henri Verbeet
96556a8834 vkd3d-shader/hlsl: Add support for RWTexture2DArray. 2023-10-19 23:07:31 +02:00
Henri Verbeet
2c71c18879 vkd3d-shader/hlsl: Add support for RWTexture1DArray. 2023-10-19 23:07:30 +02:00
Nikolay Sivov
e242b46922 vkd3d-shader/tpf: Convert some of the semantic names to system values names when in compatibility mode. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-19 23:03:23 +02:00
Conor McCarthy
a4ed06bc5b vkd3d-shader/d3d-asm: Recognise the 'rasteriser ordered view' UAV flag. 2023-10-18 20:58:27 +02:00
Henri Verbeet
b63c853688 vkd3d-utils: Implement D3DGetBlobPart(). 
This was largely adapted from Wine's d3dcompiler_43, with some style
adjustments.
 2023-10-18 20:58:22 +02:00
Henri Verbeet
4e8ba62481 vkd3d-shader/spirv: Initialise "symbol.descriptor_array" in spirv_compiler_emit_combined_sampler_declarations(). 
Besides simply avoiding carrying around some uninitialised data, we
check "symbol->descriptor_array" in spirv_compiler_prepare_image(), both
for separate resources and for combined resource/sampler symbols.
 2023-10-17 22:18:44 +02:00
Conor McCarthy
85c165ff39 vkd3d-shader/dxil: Read DXIL compute shader thread group dimensions. 2023-10-17 22:18:26 +02:00
Conor McCarthy
4b7ca0c294 vkd3d-shader/dxil: Read DXIL global flags. 2023-10-17 22:18:25 +02:00
Conor McCarthy
06f8a88466 vkd3d-shader: Define more global flags. 2023-10-17 22:18:23 +02:00
Conor McCarthy
e0d0a04b79 vkd3d-shader/dxil: Handle multi-row signature elements. 2023-10-16 22:36:38 +02:00
Conor McCarthy
7113064a19 vkd3d-shader/dxil: Handle signature element additional tag/value pairs. 2023-10-16 22:36:36 +02:00
Conor McCarthy
8648ca0e77 vkd3d-shader/dxil: Read the DXIL input and output signatures. 
These can differ from the DXBC signatures by having multiple rows, and
load/store instructions reference them by id instead of register index.
 2023-10-16 22:36:29 +02:00
Conor McCarthy
62badbff7a vkd3d-shader/dxil: Validate the entry point info. 2023-10-16 22:36:28 +02:00
Francisco Casas
38a7309758 vkd3d-shader/d3dbc: Use D3DSIO_TEXKILL instead of VKD3D_SM1_OP_TEXKILL (clangd). 2023-10-12 23:27:24 +02:00
Francisco Casas
7960836551 vkd3d-shader/hlsl: Remove enum hlsl_error_level (clangd). 
It is only used once for calling hlsl_note(), and it expects an enum
vkd3d_shader_log_level values instead.
 2023-10-12 23:27:22 +02:00
Francisco Casas
432fa8fa8f vkd3d-shader/tpf: Avoid translations to D3DDECLUSAGE and back (clangd). 2023-10-12 23:27:19 +02:00
Francisco Casas
f0da419a8c vkd3d-shader: Remove unnecessary fallthroughs (clangd). 2023-10-12 23:27:19 +02:00
Conor McCarthy
6034f4a976 vkd3d-shader/dxil: Read DXIL metadata named nodes. 2023-10-12 18:23:33 +02:00
Conor McCarthy
4ac201788d vkd3d-shader/dxil: Read DXIL metadata kinds. 2023-10-12 18:23:32 +02:00
Conor McCarthy
cba3e18c45 vkd3d-shader/dxil: Read DXIL metadata values. 2023-10-12 18:23:31 +02:00
Conor McCarthy
5817fabc30 vkd3d-shader/dxil: Read DXIL metadata nodes. 2023-10-12 18:23:30 +02:00
Conor McCarthy
a62343f544 vkd3d-shader/dxil: Read DXIL metadata strings. 2023-10-12 18:23:29 +02:00
Conor McCarthy
05d516bb00 vkd3d-shader/dxil: Emit an error on allocation failure in dxil_record_to_string(). 2023-10-11 22:21:22 +02:00
Conor McCarthy
52dc6f252c vkd3d-shader/dxil: Read global constants in sm6_parser_globals_init(). 
These are needed for reading metadata.
 2023-10-11 22:21:20 +02:00
Conor McCarthy
df4e1b7393 vkd3d-shader/dxil: Read immediate constant arrays. 2023-10-11 22:21:19 +02:00
Zebediah Figura
6a942581db vkd3d-shader/ir: Translate TEX instructions to SAMPLE. 2023-10-09 21:58:40 +02:00
Zebediah Figura
bd9eae6c22 vkd3d-shader: Scan combined sampler declarations. 
This does not handle 1.x samplers yet.
 2023-10-09 21:58:38 +02:00
Zebediah Figura
2bcd6ea893 vkd3d-shader: Introduce a separate register type for combined samplers. 2023-10-09 21:58:38 +02:00
Nikolay Sivov
3af629cf8c vkd3d-shader/tpf: Output interpolation modifiers for input declarations. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-09 21:58:31 +02:00
Nikolay Sivov
8479ceedfc vkd3d-shader/hlsl: Propagate structure fields modifiers when copying shader inputs. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-09 21:58:29 +02:00
Nikolay Sivov
1930b51d97 vkd3d-shader/hlsl: Allow interpolation modifiers on structure fields. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-09 21:58:27 +02:00
Nikolay Sivov
de860c3cbf vkd3d-shader/hlsl: Parse 'centroid' and 'noperspective' modifiers. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-09 21:58:24 +02:00
Nikolay Sivov
c5414fa92f vkd3d-shader/tpf: Write 'continue' instruction. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-09 21:58:17 +02:00
Nikolay Sivov
e4b423d6b5 vkd3d-shader/hlsl: Handle 'continue' statements. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-09 21:58:14 +02:00
Nikolay Sivov
0e5749e78e vkd3d-shader/hlsl: Allow 'break' instructions in loops. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-09 21:58:12 +02:00
Conor McCarthy
75c2af3640 vkd3d-shader/spirv: When declaring a CBV initialise the register with the register index range. 
The declaration instruction register contains id, range first, and range
last. The backend includes range first in the variable name. After commit
e8b3561252 it was always zero, and since commit 67f0196c33 it is
UINT_MAX, so constant buffers are named, e.g., "%cb0_4294967295".
 2023-10-09 21:58:01 +02:00
Zebediah Figura
a4c5f3a798 vkd3d-shader/spirv: Add a debug name for the push constant buffer. 2023-10-09 21:57:53 +02:00
Henri Verbeet
98d158d004 vkd3d-shader/tpf: Get rid of the output map. 
Map output registers in the backend instead, as needed.
 2023-10-09 21:57:46 +02:00
Henri Verbeet
31ce7c3a38 vkd3d-shader/hlsl: Get rid of the vkd3d_sm4_* forward declarations in hlsl.h. 
These are no longer needed outside of tpf.c.
 2023-10-09 21:57:38 +02:00
Francisco Casas
014960b64b vkd3d-shader/tpf: Use lookup table for opcode_info_from_sm4(). 
Makes get_opcode_info() and thus, tpf reading a little faster.
 2023-10-05 16:16:27 +02:00
Francisco Casas
88b644a11d vkd3d-shader/tpf: Don't store sm4 instruction extra bits in the opcode. 
Adding extra bits to instr->opcode doesn't seem correct, given that it
is an enum.

For instance, get_opcode_info() would return NULL if additional bits are
added to instr->opcode. This is not a problem now because that function
is called when reading and not writing.
 2023-10-05 16:16:24 +02:00
Francisco Casas
0a5fa80f02 vkd3d-shader/tpf: Apply mask to swizzle when swizzle type is scalar. 
In native's output, for scalar swizzles only the first component of the
swizzle is written, the others are left as zero.
 2023-10-05 16:16:21 +02:00
Francisco Casas
f06169afc5 vkd3d-shader/tpf: Don't calculate instruction size in advance. 
Co-authored-by: Henri Verbeet <hverbeet@codeweavers.com>
 2023-10-05 16:16:19 +02:00
Nikolay Sivov
7c378cc6f9 vkd3d-shader/hlsl: Remove conditional branching when condition is a compile time constant. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-05 16:16:09 +02:00
Nikolay Sivov
f3389789b2 vkd3d-shader: Add constant folding for 'rsq'. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-05 16:16:03 +02:00
Nikolay Sivov
a58c659b10 vkd3d-shader/hlsl: Add constant folding for binary complement operator. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-05 16:15:56 +02:00
Nikolay Sivov
8ebccad3c9 vkd3d-shader/hlsl: Add constant folding for rshift. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-05 16:15:54 +02:00
Nikolay Sivov
6e74819eb7 vkd3d-shader/hlsl: Add constant folding for lshift. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-05 16:15:52 +02:00
Nikolay Sivov
8c9d65d6b3 vkd3d-shader/hlsl: Add constant folding for logical 'not', for bools. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-05 16:15:50 +02:00
Francisco Casas
4ab6572be7 vkd3d-shader/hlsl: Replace hlsl_type_get_regset() uses with hlsl_deref_get_regset(). 2023-10-05 16:15:37 +02:00
Francisco Casas
a214b7374b vkd3d-shader/hlsl: Avoid hlsl_type_get_regset() in allocate_register_reservations(). 2023-10-05 16:15:34 +02:00
Francisco Casas
cd0e3786c3 vkd3d-shader/hlsl: Avoid hlsl_type_get_regset() in sm4_get_extern_resources(). 2023-10-05 16:15:28 +02:00
Francisco Casas
dfce1e7f4a vkd3d-shader/hlsl: Make regset an output argument in hlsl_type_get_component_offset(). 
Components only span across a single regset, so instead of expecting the
regset as input for the offset, hlsl_type_get_component_offset() can
actually retrieve it.
 2023-10-05 16:15:26 +02:00
Nikolay Sivov
b5c0c9c22f vkd3d-shader/hlsl: Add fwidth() function. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-10-05 16:15:10 +02:00
Alistair Leslie-Hughes
71715cc434 vkd3d-shader: Fix compiler warning. 
vkd3d-shader/tpf.c:3810:39: warning: passing argument 2 of ‘sm4_register_from_node’ from incompatible pointer type [-Wincompatible-pointer-types]
vkd3d-shader/tpf.c:4750:59: warning: passing argument 3 of ‘sm4_register_from_deref’ from incompatible pointer type [-Wincompatible-pointer-types]

Change to use uint32_t as requested.
 2023-10-05 16:14:44 +02:00
Francisco Casas
c92772657f vkd3d-shader/tpf: Replace sm4_src_register with vkd3d_shader_src_param. 2023-10-03 21:27:48 +02:00
Francisco Casas
13f62e60e1 vkd3d-shader/tpf: Remove sm4_src_register.swizzle_type. 2023-10-03 21:27:47 +02:00
Francisco Casas
32f03468fc vkd3d-shader/tpf: Make sm4_src_register.mod a vkd3d_shader_src_modifier enum. 2023-10-03 21:27:45 +02:00
Francisco Casas
f50d0ae2cb vkd3d-shader/tpf: Store vkd3d-shader swizzles in sm4_src_register.swizzle. 2023-09-28 23:13:16 +02:00
Francisco Casas
ef9ec28eb0 vkd3d-shader/tpf: Replace sm4_dst_register with vkd3d_shader_dst_param. 2023-09-28 23:13:14 +02:00
Francisco Casas
d41d8f8771 vkd3d-shader/tpf: Rename sm4_dst_register.writemask to write_mask. 2023-09-28 23:13:12 +02:00
Francisco Casas
123e399b89 vkd3d-shader/d3d-asm: Don't print offset for DEPTHOUT registers. 
This register is unique and thus is not accompanied with an offset in
the native disassembler output.
 2023-09-27 22:34:48 +02:00
Francisco Casas
ef1567c17b vkd3d-shader/d3d-asm: Use vkd3d_shader_register.dimension to know when to dump writemask. 
This change ensures that we don't dump the writemask for registers that
have a scalar dimension.

For instance, for this shader:

    float r;

    float4 main(out float d : DEPTH) : sv_target
    {
        d = r;
        return 0;
    }

we now correctly dump

    dcl_output oDepth

instead of

    dcl_output oDepth.x
 2023-09-27 22:34:47 +02:00
Francisco Casas
a358722f71 vkd3d-shader/d3d-asm: Use vkd3d_shader_register.dimension to know when to dump swizzle. 
The assumption that sampler registers never have a swizzle is not
totally correct.

For instance, for the following shader:

    Texture2D tex;
    sampler sam;

    float4 main() : sv_target
    {
        return tex.GatherGreen(sam, float2(0, 0));
    }

the gather instruction is being disassembled as

  gather4_indexable(texture2d) o0.xyzw, l(0.0, 0.0, 0.0, 0.0), t0.xyzw, s0

instead of

  gather4_indexable(texture2d)(float,float,float,float) o0.xyzw, l(0.0, 0.0, 0.0, 0.0), t0.xyzw, s0.y

(notice the missing swizzle in the last parameter s0).

This is because the Gather instructions give the sampler register a vec4
dimension (and scalar swizzle type) to indicate the channel for the
gather operation.

The solution is using the new vkd3d_shader_register.dimension instead of
checking the swizzle type.
 2023-09-27 22:34:46 +02:00
Francisco Casas
8e0fe29bfc vkd3d-shader/tpf: Replace sm4_register with vkd3d_shader_register. 2023-09-27 22:34:31 +02:00
Francisco Casas
10bbc7eda5 vkd3d-shader/tpf: Move sm4_register.mod to sm4_src_register. 2023-09-27 22:34:30 +02:00
Francisco Casas
8124ba3a54 vkd3d-shader/tpf: Put sm4_register.immconst_uint inside a union. 2023-09-27 22:34:28 +02:00
Francisco Casas
0c8b74cb39 vkd3d-shader/tpf: Turn sm4_register.dim into an enum vkd3d_shader_dimension. 2023-09-27 22:34:26 +02:00
Conor McCarthy
f61c853f61 vkd3d-shader/dxil: Convert into an error the warning for an unhandled instrinsic. 2023-09-26 22:07:51 +02:00
Conor McCarthy
b30b95e824 vkd3d-shader/dxil: Do not access null code blocks on failure. 2023-09-26 22:07:50 +02:00
Francisco Casas
74d79c7e45 vkd3d-shader/d3dbc: Initialize register dimension for all register types. 2023-09-26 22:07:06 +02:00
Francisco Casas
33f47c5ae9 vkd3d-shader/tpf: Parse register dimension for all register types. 2023-09-26 22:07:04 +02:00
Francisco Casas
e904660497 vkd3d-shader: Turn vkd3d_shader_register.immconst_type into vkd3d_shader_register.dimension. 2023-09-26 22:07:04 +02:00
Francisco Casas
dc35125d73 vkd3d-shader/tpf: Use vsir_register_init() in shader_sm1_parse_dst_param(). 2023-09-26 22:07:03 +02:00
Francisco Casas
51aa5a45e9 vkd3d-shader/tpf: Use vsir_register_init() in shader_sm1_parse_src_param(). 2023-09-26 22:07:02 +02:00
Francisco Casas
c1d9e776e2 vkd3d-shader/tpf: Use vsir_register_init() in shader_sm4_read_param(). 2023-09-26 22:07:01 +02:00
Francisco Casas
6f5cb219f4 vkd3d-shader/spirv: Use vsir_register_init() in spirv_compiler_emit_default_control_point_phase(). 2023-09-26 22:07:00 +02:00
Francisco Casas
81802e27d0 vkd3d-shader/spirv: Use vsir_register_init() in spirv_compiler_emit_resource_declaration(). 2023-09-26 22:06:59 +02:00
Francisco Casas
314c6e4808 vkd3d-shader/spirv: Use vsir_register_init() in spirv_compiler_emit_sampler_declaration(). 2023-09-26 22:06:58 +02:00
Francisco Casas
b2f262467f vkd3d-shader/spirv: Use vsir_register_init() in spirv_compiler_emit_dcl_immediate_constant_buffer(). 2023-09-26 22:06:56 +02:00
Francisco Casas
67f0196c33 vkd3d-shader/spirv: Use vsir_register_init() in spirv_compiler_emit_cbv_declaration(). 2023-09-26 22:06:55 +02:00
Francisco Casas
04529bc0b7 vkd3d-shader/spirv: Use vsir_register_init() in spirv_compiler_emit_dcl_indexable_temp(). 2023-09-26 22:06:54 +02:00
Francisco Casas
e174f6b413 vkd3d-shader/spirv: Use vsir_register_init() in spirv_compiler_emit_hull_shader_builtins(). 2023-09-26 22:06:53 +02:00
Francisco Casas
89d7bd7a81 vkd3d-shader/spirv: Use vsir_register_init() in spirv_compiler_get_invocation_id(). 2023-09-26 22:06:52 +02:00
Francisco Casas
5d6899888d vkd3d-shader: Rename shader_register_init() to vsir_register_init(). 2023-09-26 22:06:50 +02:00
Giovanni Mascellani
d9c8b49ea0 vkd3d-shader/ir: Remove dead code during normalisation. 
The SPIR-V backend generates invalid SPIR-V code when
VSIR has dead code (except for NOPs).
 2023-09-25 22:07:27 +02:00
Zebediah Figura
fcda20a8c3 vkd3d-shader/hlsl: Use lower_ir() for lower_sqrt(). 2023-09-25 22:07:23 +02:00
Zebediah Figura
496a3a2093 vkd3d-shader/hlsl: Use lower_ir() for lower_division(). 2023-09-25 22:07:22 +02:00
Zebediah Figura
ecd781e809 vkd3d-shader/hlsl: Use lower_ir() for lower_int_abs(). 2023-09-25 22:07:21 +02:00
Zebediah Figura
7944ee9bed vkd3d-shader/hlsl: Use lower_ir() for lower_casts_to_bool(). 2023-09-25 22:07:20 +02:00
Zebediah Figura
65bf6e997c vkd3d-shader/hlsl: Use lower_ir() for more passes. 2023-09-25 22:07:18 +02:00
Petrichor Park
976fd67f51 vkd3d-shader/hlsl: Implement intrinsic tan. 
This commit also extends the trigonometry tests a little bit to make
sure that tan works right.
 2023-09-25 22:07:13 +02:00
Conor McCarthy
6ec5e5bf54 vkd3d-shader/dxil: Implement DX instruction LoadInput. 2023-09-25 22:07:09 +02:00
Conor McCarthy
644a06dcca vkd3d-shader/dxil: Declare shader inputs. 2023-09-25 22:07:08 +02:00
Conor McCarthy
5984b4e455 vkd3d-shader/dxbc: Load input signatures also from ISG1 chunks. 
When DXBC contains DXIL code it uses ISG1 signatures.
 2023-09-25 22:07:06 +02:00
Conor McCarthy
575135a9ce vkd3d-shader/spirv: Build undefined values once. 2023-09-25 22:07:05 +02:00
Conor McCarthy
3249723972 vkd3d-shader/spirv: Introduce a Static Single Assignment register type. 2023-09-25 22:07:04 +02:00
Conor McCarthy
a67a85989f vkd3d-shader/d3d-asm: Trace undefined registers. 2023-09-25 22:07:02 +02:00
Conor McCarthy
b765f3c770 vkd3d-shader: Make the paramater allocator slab size at least MAX_REG_OUTPUT. 
The allocator is used for DXIL input/output parameter arrays.
 2023-09-25 22:07:01 +02:00
Zebediah Figura
257a351f37 vkd3d-shader/spirv: Flush NaN to zero in ftoi. 2023-09-25 22:06:45 +02:00
Zebediah Figura
a5b6162d25 vkd3d-shader/spirv: Clamp ftoi upper bound to INT_MAX. 2023-09-25 22:06:44 +02:00
Zebediah Figura
9dee15da5b vkd3d-shader/spirv: Clamp ftoi lower bound to INT_MIN. 2023-09-25 22:06:43 +02:00
Zebediah Figura
cc893a3368 vkd3d-shader/spirv: Clamp ftou upper bound to UINT_MAX. 2023-09-25 22:06:41 +02:00
Zebediah Figura
491146fa94 vkd3d-shader/spirv: Clamp ftou lower bound to zero. 2023-09-25 22:06:39 +02:00
Nikolay Sivov
485cbe8cb7 vkd3d-shader/hlsl: Add constant folding for 'sat'. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-09-22 11:06:35 +02:00
Nikolay Sivov
89c99cccce vkd3d-shader/hlsl: Add constant folding for 'exp2'. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-09-22 11:06:34 +02:00
Nikolay Sivov
c16c5caad8 vkd3d-shader/hlsl: Add constant folding for 'fract'. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-09-22 11:06:33 +02:00
Giovanni Mascellani
c69562128a vkd3d-shader/hlsl: Correctly fold casts from double. 2023-09-22 11:06:29 +02:00
Giovanni Mascellani
49bbd98a04 vkd3d-shader/hlsl: Correctly fold casts from float. 
I.e., without invoking undefined behavior in the compiler. The rules
are desumed from the the MSDN documentation for ftoi and ftou.
 2023-09-22 11:06:28 +02:00
Nikolay Sivov
d9c984c11a vkd3d-shader/hlsl: Add constant folding for the ternary operator. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-09-22 11:06:23 +02:00
Nikolay Sivov
6d1ba83856 vkd3d-shader/hlsl: Use conditional moves for arithmetic operators instead of branching. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-09-22 11:06:22 +02:00
Giovanni Mascellani
34b1c0fe5d vkd3d-shader/ir: Validate source parameters. 2023-09-22 11:06:18 +02:00
Giovanni Mascellani
603170106c vkd3d-shader/ir: Validate destination parameters. 2023-09-22 11:06:17 +02:00
Giovanni Mascellani
585e60ad3b vkd3d-shader/ir: Validate register types. 2023-09-22 11:06:16 +02:00
Giovanni Mascellani
b09cfbda90 vkd3d-shader/ir: Validate instruction handlers. 2023-09-22 11:06:15 +02:00
Giovanni Mascellani
c052cd8998 vkd3d-shader/ir: Introduce a boilerplate to validate the generated IR. 
For the moment the validator is trivial, it never fails. Checks will
be added incrementally.
 2023-09-22 11:06:13 +02:00
Giovanni Mascellani
cf871d2cb2 vkd3d-shader: Embed the parsing location in vkd3d_shader_instruction. 
So that it can be used for printing meaningful error locations by
downstream processors.
 2023-09-22 11:06:12 +02:00
Giovanni Mascellani
531c41306d vkd3d-shader/dxil: Destroy the SM6 parser on parsing errors. 2023-09-22 11:06:11 +02:00
Giovanni Mascellani
78220ed07e vkd3d-shader/tpf: Destroy the SM4 parser on parsing errors. 2023-09-22 11:06:10 +02:00
Giovanni Mascellani
a2fb9588c7 vkd3d-shader/d3dbc: Destroy the SM1 parser on parsing errors. 2023-09-22 11:06:09 +02:00
Giovanni Mascellani
d1cb6b41b1 vkd3d-shader/d3dbc: Skip DCL semantic tokens properly. 2023-09-22 11:06:08 +02:00
Giovanni Mascellani
9487cc6ab5 vkd3d-shader/ir: Simplify the control flow in shader_instruction_normalise_io_params(). 2023-09-22 11:06:06 +02:00
Giovanni Mascellani
5220125c9f vkd3d-shader/ir: Fully reinitialize an instruction when making it a NOP. 2023-09-22 11:06:05 +02:00
Giovanni Mascellani
05af25eecb vkd3d-shader: Rename shader_instruction_init(). 2023-09-22 11:06:05 +02:00
Henri Verbeet
90d4529f27 Release 1.9. 2023-09-21 19:16:32 +02:00
Zebediah Figura
9417c7cfb7 vkd3d-shader/d3dbc: Translate sm1 fragment outputs to system values. 2023-09-21 19:16:31 +02:00
Zebediah Figura
1615e5a76b vkd3d-shader/dxbc: Map sm4 fragment outputs to system values based on their name. 2023-09-21 19:16:29 +02:00
Zebediah Figura
fd120d8f2d vkd3d-shader: Rename vkd3d_shader_next_stage_info to vkd3d_shader_varying_map_info. 
It was originally intended that this structure could hold other information
about the next stage which compilation might depend on. For example, compilation
to GLSL needs to know the type of the next shader in some circumstances.

That was never actualized, and since the API is fixed at this point for 1.9, it
makes the most sense to rename the structure to match its actual scope.

The documentation was written and arranged to imply that the structure would
hold other information about the next shader than the varying map; this is
changed accordingly as well.
 2023-09-21 19:16:27 +02:00
Henri Verbeet
f796d8668e vkd3d-shader: Export vkd3d_shader_build_varying_map. 2023-09-19 21:30:35 +02:00
Henri Verbeet
da89da2bf3 vkd3d-shader: Hide support for DXIL sources. 
Unfortunately this is not sufficiently ready to release.
 2023-09-18 21:04:19 +02:00
Giovanni Mascellani
ee28861837 vkd3d-shader/hlsl: Document some possibly obscure HLSL opcodes. 2023-09-14 20:28:55 +02:00
Giovanni Mascellani
f251da574c vkd3d-shader/hlsl: Remove HLSL_OP3_LERP. 
It is unused, and it's not clear whether it would be of any help to
have it.
 2023-09-14 20:28:54 +02:00
Nikolay Sivov
45541dd9b2 vkd3d-shader/asm: Tweak TEXCOORD declaration name. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-09-13 23:11:16 +02:00
Nikolay Sivov
ee6c66eb1b vkd3d-shader/d3dbc: Disallow 1D sampler types when writing sampler declaration. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-09-13 23:11:14 +02:00
Nikolay Sivov
177ea3bcbd vkd3d-shader/hlsl: Produce 2D resource declarations and loads for tex1D(). 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-09-13 23:11:11 +02:00
Francisco Casas
39563aa5b3 vkd3d-shader/hlsl: Lower matrix swizzles. 2023-09-13 23:10:38 +02:00
Nikolay Sivov
fc2aaee224 vkd3d-shader: Use ternary operator in fmod() implementation. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-09-07 19:15:26 +02:00
Nikolay Sivov
1002a6b357 vkd3d-shader/tpf: Use 'movc' to implement ternary operator. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-09-07 19:15:25 +02:00
Nikolay Sivov
c5d680d141 vkd3d-shader/hlsl: Add tex1D() function. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-09-07 19:15:06 +02:00
Conor McCarthy
3badab2086 vkd3d-shader: Handle size in bytes in spirv_compiler_emit_cbv_declaration(). 
The caller passes a byte size now.
 2023-09-04 20:25:33 +02:00
Conor McCarthy
bad4c74002 vkd3d-shader: Match only UAV descriptors in vkd3d_shader_scan_add_uav_flag(). 
Fixes compilation failures in Cyberpunk 2077 due to missing UAV counter
flag.
 2023-09-04 20:25:31 +02:00
Zebediah Figura
a597dc8755 vkd3d-shader/hlsl: Define lit() in HLSL. 2023-08-30 22:49:03 +02:00
Zebediah Figura
9ab77658f2 vkd3d-shader/hlsl: Define smoothstep() in HLSL. 2023-08-30 22:49:01 +02:00
Zebediah Figura
d396c4ce27 vkd3d-shader/hlsl: Store the internal name counter in struct hlsl_ctx. 
This is minutely more efficient than using a global variable and atomic instructions.
 2023-08-30 22:48:59 +02:00
Zebediah Figura
f22e52f358 vkd3d-shader/hlsl: Separate an add_user_call() helper. 2023-08-30 22:48:57 +02:00
Zebediah Figura
63e056512d vkd3d-shader/hlsl: Introduce an hlsl_sprintf_alloc() helper. 2023-08-30 22:48:55 +02:00
Conor McCarthy
d27b8eb2c0 vkd3d-shader/dxil: Implement DX instruction StoreOutput. 2023-08-30 22:48:52 +02:00
Conor McCarthy
bf49a1a95b vkd3d-shader/dxil: Declare shader outputs. 2023-08-30 22:48:50 +02:00
Conor McCarthy
e54f770669 vkd3d-shader/dxil: Implement the DXIL CALL instruction. 2023-08-30 22:48:48 +02:00
Conor McCarthy
720a087c28 vkd3d-shader/dxil: Replace the result type enum with a bool. 
Changes to failure handling make the enum unnecessary.
 2023-08-30 22:48:47 +02:00
Conor McCarthy
58d6e44501 vkd3d-shader/dxil: Validate the function block count. 2023-08-30 22:48:45 +02:00
Conor McCarthy
61a550017f vkd3d-shader/spirv: Handle signature element mask left shift in spirv_compiler_emit_output(). 
Element masks can have a left shift in DXIL, but these must start at
bit 0 in the register info. The SPIR-V declaration will either be a
builtin or have SpvDecorationComponent.
 2023-08-30 22:48:43 +02:00
Conor McCarthy
ebc461f795 vkd3d-shader/spirv: Handle signature element mask left shift in calculate_clip_or_cull_distance_mask(). 
In DXIL these masks can have a left shift.
 2023-08-30 22:48:41 +02:00
Nikolay Sivov
c39c5b3907 vkd3d-shader/hlsl: Add texCUBE() function. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-08-29 22:07:56 +02:00
Zebediah Figura
9624e2f904 vkd3d-shader/spirv: Declare SRVs and UAVs from the descriptor info. 2023-08-28 20:40:02 +02:00
Zebediah Figura
e8b3561252 vkd3d-shader/spirv: Declare constant buffers from the descriptor info. 2023-08-28 20:40:01 +02:00
Zebediah Figura
547768bcdd vkd3d-shader/spirv: Declare samplers from the descriptor info. 2023-08-28 20:39:59 +02:00
Zebediah Figura
a1e10e5c90 vkd3d-shader/spirv: Split spirv_compiler_has_combined_sampler() into two functions. 
These functions do not really share any code in common.
 2023-08-28 20:39:57 +02:00
Nikolay Sivov
18c1477464 vkd3d-shader/hlsl: Ignore 'inline' modifier for functions. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-08-28 20:39:53 +02:00
Conor McCarthy
61841e9423 vkd3d-shader/tpf: Handle the swizzle type bitfield in dst param tokens. 2023-08-28 20:39:49 +02:00
Conor McCarthy
eddae47062 vkd3d-shader/tpf: Handle the dimension bitfield in dst param tokens. 
A zero mask is still emitted for some scalar registers. This has no
effect on current tests, but keeping the correction is probably a good
idea.
 2023-08-28 20:39:48 +02:00
Conor McCarthy
92021b7a3c vkd3d-shader/tpf: Use the default vec4 swizzle if a src param contains a mask. 2023-08-28 20:39:46 +02:00
Conor McCarthy
7e5d9e3b6f vkd3d-shader/tpf: Handle the dimension bitfield in src param tokens. 2023-08-28 20:39:45 +02:00
Conor McCarthy
5c706152fa vkd3d-shader/tpf: Validate the src register of case conditions. 
Case values are constants in TPF.
 2023-08-28 20:39:43 +02:00
Francisco Casas
ed9e236b01 vkd3d-shader/tpf: Avoid reading constant value components beyond type's width (Valgrind). 
We are passing map writemasks that may have more components than the
constant's data type, so a (j < width) check is added to avoid reading
components from the constant that are not intended to be used.

Remaining values in the register are initialized to zero.
 2023-08-24 21:43:55 +02:00
Nikolay Sivov
89eda51855 vkd3d-shader/hlsl: Change warning code for unknown loop attributes. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-08-24 21:43:50 +02:00
Nikolay Sivov
1153f6bb34 vkd3d-shader/hlsl: Parse "if" statement attributes. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-08-24 21:43:49 +02:00
Zebediah Figura
926575a6f3 vkd3d-shader/hlsl: Force sm1 inputs to be 4-component only for vertex shaders. 
Pixel shaders still have an appropriate writemask.
 2023-08-24 21:43:44 +02:00
Zebediah Figura
622311da8e vkd3d-shader: Add a flag marking raw buffers to struct vkd3d_shader_descriptor_info. 2023-08-23 22:45:04 +02:00
Zebediah Figura
c1ebba9515 vkd3d-shader: Add structure stride to struct vkd3d_shader_descriptor_info1. 2023-08-23 22:45:04 +02:00
Zebediah Figura
88f85ffb50 vkd3d-shader: Add constant buffer size to struct vkd3d_shader_descriptor_info1. 2023-08-23 22:45:04 +02:00
Zebediah Figura
8c465c81cf vkd3d-shader: Add sample count to struct vkd3d_shader_descriptor_info1. 2023-08-23 22:45:04 +02:00
Zebediah Figura
ccedb7f711 vkd3d-shader: Set descriptor flags in the caller to vkd3d_shader_scan_add_descriptor(). 
Return the vkd3d_shader_descriptor_info1 from that function.
 2023-08-23 22:45:02 +02:00
Nikolay Sivov
4f2e07a45d vkd3d-shader/hlsl: Allow 'const' modifier without initializer in the global scope. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-08-15 21:51:50 +02:00
Zebediah Figura
240b9424fb vkd3d-shader/hlsl: Pass an hlsl_block pointer to append_output_copy(). 2023-08-15 21:51:47 +02:00
Zebediah Figura
a04e3a51dd vkd3d-shader/hlsl: Pass an hlsl_block pointer to prepend_input_copy(). 2023-08-15 21:51:39 +02:00
Zebediah Figura
7a4ac1afb1 vkd3d-shader/hlsl: Pass an hlsl_block pointer to prepend_uniform_copy(). 2023-08-15 21:51:37 +02:00
Francisco Casas
96f66aa4f8 vkd3d-shader/d3dbc: Use the bind count instead of the allocation size in d3dbc.c. 
This should have no effect, since in SM1 the allocation size is the
same as the bind count because there are no texture registers.
It is just done for consistency.
 2023-08-15 21:51:33 +02:00
Francisco Casas
d4a49d788a vkd3d-shader/hlsl: Simplify computation of allocation size. 2023-08-15 21:51:32 +02:00
Francisco Casas
37cfbe47d7 vkd3d-shader/hlsl: Sort synthetic separated samplers first for SM4. 2023-08-15 21:51:31 +02:00
Francisco Casas
81afe43569 vkd3d-shader/tpf: Put the actual bind count in the RDEF table. 2023-08-15 21:51:29 +02:00
Francisco Casas
7eba063136 vkd3d-shader/hlsl: Rename hlsl_reg.bind_count to hlsl_reg.allocation_size. 
We have to distinguish between the "bind count" and the "allocation size"
of variables.

The "allocation size" affects the starting register id for the resource to
be allocated next, while the "bind count" is determined by the last field
actually used. The former may be larger than the latter.

What we are currently calling hlsl_reg.bind_count is actually the
"allocation size", so a rename is in order.

The real "bind count", which will be introduced in following patches,
is important because it is what should be shown in the RDEF table and
some resource allocation rules depend on it.

For instance, for this shader:

    texture2D texs[3];
    texture2D tex;

    float4 main() : sv_target
    {
        return texs[0].Load(int3(0, 0, 0)) + tex.Load(int3(0, 0, 0));
    }

the variable "texs" has a "bind count" of 1, but an "allocation size" of
3:

    // Resource Bindings:
    //
    // Name                                 Type  Format         Dim      HLSL Bind  Count
    // ------------------------------ ---------- ------- ----------- -------------- ------
    // texs                              texture  float4          2d             t0      1
    // tex                               texture  float4          2d             t3      1
 2023-08-15 21:51:27 +02:00
Nikolay Sivov
98f63c46f8 vkd3d-shader/hlsl: Use type width in fold_rcp(). 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-08-14 18:38:21 +02:00
Nikolay Sivov
932c5e36dc vkd3d-shader/hlsl: Add constant folding for 'log2'. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-08-14 18:38:20 +02:00
Nikolay Sivov
58bc61e48d vkd3d-shader/hlsl: Add constant folding for 'sqrt'. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-08-14 18:38:18 +02:00
Nikolay Sivov
7e99188dc7 vkd3d-shader: Add constant folding for 'dp2add' operation. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-08-14 18:38:15 +02:00
Nikolay Sivov
25ff56769b vkd3d-shader: Add constant folding for the 'dot' operation. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-08-14 18:38:15 +02:00
Zebediah Figura
983d01df8c vkd3d-shader: Get rid of the uav_ranges array. 
This is now redundant; the register ID is encoded into the scan descriptors.
 2023-08-14 18:38:11 +02:00
Zebediah Figura
7d02922541 vkd3d-shader: Add register ID to struct vkd3d_shader_descriptor_info1. 2023-08-14 18:38:11 +02:00
Zebediah Figura
4e9798f6f7 vkd3d-shader: Introduce struct vkd3d_shader_scan_descriptor_info1. 2023-08-14 18:38:11 +02:00
Zebediah Figura
fd4a820c4b vkd3d-shader: Centralize cleanup on error in scan_with_parser(). 2023-08-14 18:38:11 +02:00
Zebediah Figura
9c5cb2de18 vkd3d-shader: Factor more code into vkd3d_shader_scan_get_uav_descriptor_info(). 2023-08-14 18:38:11 +02:00
Francisco Casas
8484bd59a6 vkd3d-shader/tpf: Separate dst register write function. 2023-08-14 18:38:08 +02:00
Francisco Casas
d1c45fe2f0 vkd3d-shader/tpf: Separate src register write function. 2023-08-14 18:38:07 +02:00
Francisco Casas
2258e9d0f3 vkd3d-shader/tpf: Make register_type_table an array of structs with lookup tables. 2023-08-14 18:38:06 +02:00
Francisco Casas
c77e5f1c1f vkd3d-shader/tpf: Introduce struct tpf_writer to group sm4 write arguments. 
We will add register information lookup tables on this struct later.
They will be used by sm4_encode_register(), and thus, they will be
required by write_sm4_instruction().
 2023-08-14 18:38:05 +02:00
Francisco Casas
a584499c8a vkd3d-shader/tpf: Use struct vkd3d_shader_register_index in sm4_register.idx[]. 2023-08-14 18:38:04 +02:00
Francisco Casas
fc589add49 vkd3d-shader/tpf: Allow passing NULL register type on hlsl_sm4_register_from_semantic(). 2023-08-14 18:38:03 +02:00
Francisco Casas
8a6a620ee2 vkd3d-shader/tpf: Use enum vkd3d_shader_register_type in sm4_register.type. 2023-08-14 18:38:01 +02:00
Zebediah Figura
cf6bc95a3d vkd3d-shader/hlsl: Use hlsl_block_add_instr() in clone_block(). 2023-08-08 21:15:16 +09:00
Zebediah Figura
4ae00cea43 vkd3d-shader/hlsl: Clean up the static_initializers block when the context is destroyed (Valgrind). 
This is currently leaked if we fail parsing before reaching codegen.
 2023-08-08 21:15:13 +09:00
Zebediah Figura
b22e2113a6 vkd3d-shader/hlsl: Pass a hlsl_block pointer to dump_instr_list(). 2023-08-08 21:15:10 +09:00
Zebediah Figura
0652bb1950 vkd3d-shader/hlsl: Store the "instrs" field of struct hlsl_attribute as a hlsl_block. 2023-08-08 21:15:08 +09:00
Zebediah Figura
372ddd1f29 vkd3d-shader/hlsl: Pass an hlsl_block pointer to add_load_component(). 2023-08-08 21:15:05 +09:00
Zebediah Figura
f649db23a5 vkd3d-shader: Introduce a function to build a varying map between sm1 stages. 2023-08-03 21:20:44 +09:00
Zebediah Figura
d932fba7c3 vkd3d-shader/spirv: Make output varyings not consumed by the next stage private variables. 2023-08-03 21:20:42 +09:00
Zebediah Figura
11475ef62a vkd3d-shader: Implement remapping shader output registers to match the next shader's semantics. 2023-08-03 21:20:42 +09:00
Zebediah Figura
cb96482500 vkd3d-shader: Add a separate field for the target location of a signature element. 
We want to be able to remap input signatures based on the signature index, but
signature normalization both reorders the signature, and requires the old
register index, so add a new field for this.
 2023-08-03 21:20:39 +09:00
Zebediah Figura
bad72d1874 vkd3d-shader/d3dbc: Make sure all inter-stage varyings have a unique register index. 
spirv will need this.
 2023-08-03 21:20:22 +09:00
Zebediah Figura
b4bb3931c5 vkd3d-shader/preproc: Append spaces between tokens in macro invocations. 2023-08-02 20:19:21 +09:00
Zebediah Figura
250a24bd3f vkd3d-shader/preproc: Strip whitespace when stringifying. 2023-08-02 20:19:20 +09:00
Zebediah Figura
6fc3ae2b5c vkd3d-shader/preproc: Stringify text immediately in macro invocations. 2023-08-02 20:19:19 +09:00
Zebediah Figura
cbb1d84069 vkd3d-shader/preproc: Separate a preproc_stringify() helper. 2023-08-02 20:19:18 +09:00
Zebediah Figura
3a235b57f6 vkd3d-shader/preproc: Expand macro arguments in macro invocations. 
Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=55361
 2023-08-02 20:19:17 +09:00
Zebediah Figura
9b98489155 vkd3d-shader/preproc: Parse hash marks as two separate tokens when not in stringification contexts. 2023-08-02 20:19:15 +09:00
Zebediah Figura
9a80ff28e4 vkd3d-shader/tpf: Check buffer->status in add_section(). 2023-08-02 20:19:00 +09:00
Zebediah Figura
71afb78126 vkd3d-shader/d3dbc: Return ctx->result from hlsl_sm1_write(). 2023-08-02 20:18:59 +09:00
Zebediah Figura
6e370777b4 vkd3d-shader/d3dbc: Free vkd3d_bytecode_buffer data on failure. 2023-08-02 20:18:58 +09:00
Zebediah Figura
1bd873fb2b vkd3d-shader/d3dbc: Skip generic sampler declarations. 
Instead of asserting.
 2023-08-02 20:18:56 +09:00
Nikolay Sivov
bfdd5c142d vkd3d-shader/tpf: Add support for writing 'resinfo' instruction. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-07-31 21:07:50 +09:00
Nikolay Sivov
78719dc814 vkd3d-shader/tpf: Add support for writing 'sampleinfo' instruction. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-07-31 21:07:49 +09:00
Nikolay Sivov
d50b5fe767 vkd3d-shader/hlsl: Parse GetDimensions() method. 
Signed-off-by: Nikolay Sivov <nsivov@codeweavers.com>
 2023-07-31 21:07:48 +09:00
Zebediah Figura
819c5f1943 vkd3d-shader/hlsl: Pass an hlsl_block pointer to add_expr(). 2023-07-27 17:17:48 +09:00
Zebediah Figura
9d94506313 vkd3d-shader/hlsl: Pass an hlsl_block pointer to add_cast(). 2023-07-27 17:17:47 +09:00