RPCS3/glslang
1
0
Fork 0
mirror of https://github.com/RPCS3/glslang.git synced 2024-12-27 21:55:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
a372a3ed1e
glslang/gtests/Hlsl.FromFile.cpp

396 lines
17 KiB
C++
Raw Normal View History

Add support for testing file-based HLSL source code in GTest.
2016-05-16 16:50:30 +00:00
//
// Copyright (C) 2016 Google, Inc.
Initial implementation of direct-mapped subset of HLSL intrinsics with type subset. This checkin implements about half of the HLSL intrinsics for a subset of their entire type support (but a useful subset). The uncommented lines in TBuiltInParseablesHlsl::identifyBuiltIns shows which are connected.
2016-05-26 16:10:16 +00:00
// Copyright (C) 2016 LunarG, Inc.
Add support for testing file-based HLSL source code in GTest.
2016-05-16 16:50:30 +00:00
//
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
//
// Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
#include <gtest/gtest.h>
#include "TestFixture.h"
namespace glslangtest {
namespace {
struct FileNameEntryPointPair {
const char* fileName;
const char* entryPoint;
};
// We are using FileNameEntryPointPair objects as parameters for instantiating
// the template, so the global FileNameAsCustomTestSuffix() won't work since
// it assumes std::string as parameters. Thus, an overriding one here.
std::string FileNameAsCustomTestSuffix(
const ::testing::TestParamInfo<FileNameEntryPointPair>& info) {
std::string name = info.param.fileName;
// A valid test case suffix cannot have '.' and '-' inside.
std::replace(name.begin(), name.end(), '.', '_');
std::replace(name.begin(), name.end(), '-', '_');
return name;
}
using HlslCompileTest = GlslangTest<::testing::TestWithParam<FileNameEntryPointPair>>;
Flatten uniform arrays This checkin adds a --flatten-uniform-arrays option which can break uniform arrays of samplers, textures, or UBOs up into individual scalars named (e.g) myarray[0], myarray[1], etc. These appear as individual linkage objects. Code notes: - shouldFlatten internally calls shouldFlattenIO, and shouldFlattenUniform, but is the only flattening query directly called. - flattenVariable will handle structs or arrays (but not yet arrayed structs; this is tested an an error is generated). - There's some error checking around unhandled situations. E.g, flattening uniform arrays with initializer lists is not implemented. - This piggybacks on as much of the existing mechanism for struct flattening as it can. E.g, it uses the same flattenMap, and the same flattenAccess() method. - handleAssign() has been generalized to cope with either structs or arrays. - Extended test infrastructure to test flattening ability.
2016-09-16 19:26:37 +00:00
using HlslCompileAndFlattenTest = GlslangTest<::testing::TestWithParam<FileNameEntryPointPair>>;
Enable HLSL legalization Also added known-good mechanism to fetch latest validated spirv-tools. Also added -Od and -Os to disable optimizer and optimize for size. Fetching spirv-tools is optional for both glsl and hlsl. Legalization of hlsl is done by default if spirv-opt is present at cmake time. Optimization for glsl is currently done through the option -Os. Legalization testing is currently only done on four existing shaders. A separate baseLegalResults directory holds those results. All previous testing is done with the optimizer disabled.
2017-09-22 00:40:22 +00:00
using HlslLegalizeTest = GlslangTest<::testing::TestWithParam<FileNameEntryPointPair>>;
Add support for testing file-based HLSL source code in GTest.
2016-05-16 16:50:30 +00:00
Enable HLSL legalization Also added known-good mechanism to fetch latest validated spirv-tools. Also added -Od and -Os to disable optimizer and optimize for size. Fetching spirv-tools is optional for both glsl and hlsl. Legalization of hlsl is done by default if spirv-opt is present at cmake time. Optimization for glsl is currently done through the option -Os. Legalization testing is currently only done on four existing shaders. A separate baseLegalResults directory holds those results. All previous testing is done with the optimizer disabled.
2017-09-22 00:40:22 +00:00
// Compiling HLSL to pre-legalized SPIR-V under Vulkan semantics. Expected
// to successfully generate both AST and SPIR-V.
Add support for testing file-based HLSL source code in GTest.
2016-05-16 16:50:30 +00:00
TEST_P(HlslCompileTest, FromFile)
{
Gtests can be run on another source tree The gtest executable accepts a --test-root option to specify a root directory for test files. It defaults to the Test directory in the source tree from which the executable is built. For example, this lets us run test exectuables built with MinGW on Linux on a Windows machine with its own copy of the source tree.
2016-10-05 14:25:09 +00:00
loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
Add support for testing file-based HLSL source code in GTest.
2016-05-16 16:50:30 +00:00
Source::HLSL, Semantics::Vulkan,
Target::BothASTAndSpv, GetParam().entryPoint);
}
Flatten uniform arrays This checkin adds a --flatten-uniform-arrays option which can break uniform arrays of samplers, textures, or UBOs up into individual scalars named (e.g) myarray[0], myarray[1], etc. These appear as individual linkage objects. Code notes: - shouldFlatten internally calls shouldFlattenIO, and shouldFlattenUniform, but is the only flattening query directly called. - flattenVariable will handle structs or arrays (but not yet arrayed structs; this is tested an an error is generated). - There's some error checking around unhandled situations. E.g, flattening uniform arrays with initializer lists is not implemented. - This piggybacks on as much of the existing mechanism for struct flattening as it can. E.g, it uses the same flattenMap, and the same flattenAccess() method. - handleAssign() has been generalized to cope with either structs or arrays. - Extended test infrastructure to test flattening ability.
2016-09-16 19:26:37 +00:00
TEST_P(HlslCompileAndFlattenTest, FromFile)
{
Gtests can be run on another source tree The gtest executable accepts a --test-root option to specify a root directory for test files. It defaults to the Test directory in the source tree from which the executable is built. For example, this lets us run test exectuables built with MinGW on Linux on a Windows machine with its own copy of the source tree.
2016-10-05 14:25:09 +00:00
loadFileCompileFlattenUniformsAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
Flatten uniform arrays This checkin adds a --flatten-uniform-arrays option which can break uniform arrays of samplers, textures, or UBOs up into individual scalars named (e.g) myarray[0], myarray[1], etc. These appear as individual linkage objects. Code notes: - shouldFlatten internally calls shouldFlattenIO, and shouldFlattenUniform, but is the only flattening query directly called. - flattenVariable will handle structs or arrays (but not yet arrayed structs; this is tested an an error is generated). - There's some error checking around unhandled situations. E.g, flattening uniform arrays with initializer lists is not implemented. - This piggybacks on as much of the existing mechanism for struct flattening as it can. E.g, it uses the same flattenMap, and the same flattenAccess() method. - handleAssign() has been generalized to cope with either structs or arrays. - Extended test infrastructure to test flattening ability.
2016-09-16 19:26:37 +00:00
Source::HLSL, Semantics::Vulkan,
Target::BothASTAndSpv, GetParam().entryPoint);
}
Enable HLSL legalization Also added known-good mechanism to fetch latest validated spirv-tools. Also added -Od and -Os to disable optimizer and optimize for size. Fetching spirv-tools is optional for both glsl and hlsl. Legalization of hlsl is done by default if spirv-opt is present at cmake time. Optimization for glsl is currently done through the option -Os. Legalization testing is currently only done on four existing shaders. A separate baseLegalResults directory holds those results. All previous testing is done with the optimizer disabled.
2017-09-22 00:40:22 +00:00
// Compiling HLSL to legal SPIR-V under Vulkan semantics. Expected to
// successfully generate SPIR-V.
TEST_P(HlslLegalizeTest, FromFile)
{
loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
Source::HLSL, Semantics::Vulkan,
Target::Spv, GetParam().entryPoint,
"/baseLegalResults/", false);
}
Add support for testing file-based HLSL source code in GTest.
2016-05-16 16:50:30 +00:00
// clang-format off
INSTANTIATE_TEST_CASE_P(
ToSpirv, HlslCompileTest,
::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
Add amend ability for anonymous blocks, so they can grow between function bodies.
2016-09-30 05:58:30 +00:00
{"hlsl.amend.frag", "f1"},
HLSL: Convert run-time sampler assignments to compile-time aliases. For "s.m = t", a sampler member assigned a sampler, make t an alias for s.m, and when s.m is flattened, it will flatten to the alias t. Normally, assignments to samplers are disallowed.
2017-06-02 22:28:39 +00:00
{"hlsl.aliasOpaque.frag", "main"},
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
{"hlsl.array.frag", "PixelShaderFunction"},
HLSL: allow implicit array sizing. In HLSL array sizes need not be provided explicitly in all circumstances. For example, this is valid (note no number between the [ ]): // no explicit array size uniform float g_array[] = { 1, 2, 3, 4, 5 }; This PR does not attempt to validate most invalid cases. A new test is added to verify the resulting linker objects.
2016-09-27 16:57:35 +00:00
{"hlsl.array.implicit-size.frag", "PixelShaderFunction"},
HLSL: allow multi-dimensional arrays All the underpinnings are there; this just parses multiple array dimensions and passes them through to the existing mechanisms. Also, minor comment fixes, and add a new test for multi-dim arrays.
2016-10-13 18:26:18 +00:00
{"hlsl.array.multidim.frag", "main"},
Tests: Add a set of gtest-file-based HLSL tests.
2016-05-16 23:39:50 +00:00
{"hlsl.assoc.frag", "PixelShaderFunction"},
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
{"hlsl.attribute.frag", "PixelShaderFunction"},
HLSL: Allow expressions in attributes For example: [numthreads(2+2, 2*3, (1+FOO)*BAR)] This will result in a thread count (4, 6, 8).
2016-11-11 15:17:44 +00:00
{"hlsl.attribute.expression.comp", "main"},
HLSL: Additional attribute support: [[]], namespace, parameters: - support C++11 style brackets [[...]] - support namespaces [[vk::...]] - support these on parameter declarations in functions - support location, binding/set, input attachments
2017-09-30 20:34:50 +00:00
{"hlsl.attributeC11.frag", "main"},
HLSL: Fix #1106. Support shader setting of binding/set for $Global.
2017-10-19 22:54:25 +00:00
{"hlsl.attributeGlobalBuffer.frag", "main"},
HLSL: Support SV_Coverage and SV_DispatchThreadId; catch SV_GroupIndex.
2016-10-16 18:12:11 +00:00
{"hlsl.basic.comp", "main"},
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
{"hlsl.basic.geom", "main"},
HLSL: Fix #770: implicitly convert bool operands to numeric operators.
2017-04-13 04:37:32 +00:00
{"hlsl.boolConv.vert", "main"},
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
{"hlsl.buffer.frag", "PixelShaderFunction"},
HLSL: Add CalculateLevelOfDetail, and unimplemented errors for *Unclamped and GetSamplePosition
2016-07-26 14:57:53 +00:00
{"hlsl.calculatelod.dx10.frag", "main"},
{"hlsl.calculatelodunclamped.dx10.frag", "main"},
HLSL: 1) Implement lookahead buffers/stacks for token advance/recede, 2) use it for cast operation. The grammar now accepts type casts, like "(int)x", but that has to be disambiguated from "(a + b)", needed deeper lookahead and backing up than what existed so far.
2016-06-03 22:55:49 +00:00
{"hlsl.cast.frag", "PixelShaderFunction"},
HLSL: Fix #758: Support character literals (except for numeric escape sequences).
2017-04-12 22:31:15 +00:00
{"hlsl.charLit.vert", "main"},
HLSL: fix crash on empty sequence node passed to intrinsic expansions
2017-03-31 18:47:34 +00:00
{"hlsl.clip.frag", "main"},
HLSL: handle clip and cull distance input builtin type conversion HLSL allows a range of types for clip and cull distances. There are three dimensions, including arrayness, vectorness, and semantic ID. SPIR-V requires clip and cull distance be a single array of floats in all cases. This code provides input side conversion between the SPIR-V form and the HLSL form. (Output conversion was added in PR #947 and #997). This PR extends HlslParseContext::assignClipCullDistance to cope with the input side conversion. Not as much changed as appears: there was also a lot of renaming to reflect the fact that the code now handles either direction. Currently, non-{frag,vert} stages are not handled, and are explicitly rejected. Fixes #1026.
2017-08-23 18:34:42 +00:00
{"hlsl.clipdistance-1.frag", "main"},
{"hlsl.clipdistance-1.geom", "main"},
WIP: HLSL: handle clip/cull distance array semantic matching In HLSL, there are three (TODO: ??) dimensions of clip and cull distance values: * The semantic's value N, ala SV_ClipDistanceN. * The array demension, if the value is an array. * The vector element, if the value is a vector or array of vectors. In SPIR-V, clip and cull distance are arrays of scalar floats, always. This PR currently ignores the semantic N axis, and handles the other two axes by sequentially copying each vector element of each array member into sequential floats in the output array. Fixes: #946
2017-06-22 18:08:00 +00:00
{"hlsl.clipdistance-1.vert", "main"},
HLSL: handle clip and cull distance input builtin type conversion HLSL allows a range of types for clip and cull distances. There are three dimensions, including arrayness, vectorness, and semantic ID. SPIR-V requires clip and cull distance be a single array of floats in all cases. This code provides input side conversion between the SPIR-V form and the HLSL form. (Output conversion was added in PR #947 and #997). This PR extends HlslParseContext::assignClipCullDistance to cope with the input side conversion. Not as much changed as appears: there was also a lot of renaming to reflect the fact that the code now handles either direction. Currently, non-{frag,vert} stages are not handled, and are explicitly rejected. Fixes #1026.
2017-08-23 18:34:42 +00:00
{"hlsl.clipdistance-2.frag", "main"},
{"hlsl.clipdistance-2.geom", "main"},
WIP: HLSL: handle clip/cull distance array semantic matching In HLSL, there are three (TODO: ??) dimensions of clip and cull distance values: * The semantic's value N, ala SV_ClipDistanceN. * The array demension, if the value is an array. * The vector element, if the value is a vector or array of vectors. In SPIR-V, clip and cull distance are arrays of scalar floats, always. This PR currently ignores the semantic N axis, and handles the other two axes by sequentially copying each vector element of each array member into sequential floats in the output array. Fixes: #946
2017-06-22 18:08:00 +00:00
{"hlsl.clipdistance-2.vert", "main"},
HLSL: handle clip and cull distance input builtin type conversion HLSL allows a range of types for clip and cull distances. There are three dimensions, including arrayness, vectorness, and semantic ID. SPIR-V requires clip and cull distance be a single array of floats in all cases. This code provides input side conversion between the SPIR-V form and the HLSL form. (Output conversion was added in PR #947 and #997). This PR extends HlslParseContext::assignClipCullDistance to cope with the input side conversion. Not as much changed as appears: there was also a lot of renaming to reflect the fact that the code now handles either direction. Currently, non-{frag,vert} stages are not handled, and are explicitly rejected. Fixes #1026.
2017-08-23 18:34:42 +00:00
{"hlsl.clipdistance-3.frag", "main"},
HLSL: add geometry stage support for clip/cull distance Changes: (1) Allow clip/cull builtins as both input and output in the same shader stage. Previously, not enough data was tracked to handle this. (2) Handle the extra array dimension in GS inputs. The synthesized external variable can now be created with the extra array dimension if needed, and the form conversion code is able to handle it as well. For example, both of these GS inputs would result in the same synthesized external type: triangle in float4 clip[3] : SV_ClipDistance triangle in float2 clip[3][2] : SV_ClipDistance In the second case, the inner array dimension packs with the 2-vector of floats into an array[4], which there is an array[3] of due to the triangle geometry.
2017-08-28 20:02:19 +00:00
{"hlsl.clipdistance-3.geom", "main"},
WIP: HLSL: handle clip/cull distance array semantic matching In HLSL, there are three (TODO: ??) dimensions of clip and cull distance values: * The semantic's value N, ala SV_ClipDistanceN. * The array demension, if the value is an array. * The vector element, if the value is a vector or array of vectors. In SPIR-V, clip and cull distance are arrays of scalar floats, always. This PR currently ignores the semantic N axis, and handles the other two axes by sequentially copying each vector element of each array member into sequential floats in the output array. Fixes: #946
2017-06-22 18:08:00 +00:00
{"hlsl.clipdistance-3.vert", "main"},
HLSL: handle clip and cull distance input builtin type conversion HLSL allows a range of types for clip and cull distances. There are three dimensions, including arrayness, vectorness, and semantic ID. SPIR-V requires clip and cull distance be a single array of floats in all cases. This code provides input side conversion between the SPIR-V form and the HLSL form. (Output conversion was added in PR #947 and #997). This PR extends HlslParseContext::assignClipCullDistance to cope with the input side conversion. Not as much changed as appears: there was also a lot of renaming to reflect the fact that the code now handles either direction. Currently, non-{frag,vert} stages are not handled, and are explicitly rejected. Fixes #1026.
2017-08-23 18:34:42 +00:00
{"hlsl.clipdistance-4.frag", "main"},
HLSL: add geometry stage support for clip/cull distance Changes: (1) Allow clip/cull builtins as both input and output in the same shader stage. Previously, not enough data was tracked to handle this. (2) Handle the extra array dimension in GS inputs. The synthesized external variable can now be created with the extra array dimension if needed, and the form conversion code is able to handle it as well. For example, both of these GS inputs would result in the same synthesized external type: triangle in float4 clip[3] : SV_ClipDistance triangle in float2 clip[3][2] : SV_ClipDistance In the second case, the inner array dimension packs with the 2-vector of floats into an array[4], which there is an array[3] of due to the triangle geometry.
2017-08-28 20:02:19 +00:00
{"hlsl.clipdistance-4.geom", "main"},
WIP: HLSL: handle clip/cull distance array semantic matching In HLSL, there are three (TODO: ??) dimensions of clip and cull distance values: * The semantic's value N, ala SV_ClipDistanceN. * The array demension, if the value is an array. * The vector element, if the value is a vector or array of vectors. In SPIR-V, clip and cull distance are arrays of scalar floats, always. This PR currently ignores the semantic N axis, and handles the other two axes by sequentially copying each vector element of each array member into sequential floats in the output array. Fixes: #946
2017-06-22 18:08:00 +00:00
{"hlsl.clipdistance-4.vert", "main"},
HLSL: handle clip and cull distance input builtin type conversion HLSL allows a range of types for clip and cull distances. There are three dimensions, including arrayness, vectorness, and semantic ID. SPIR-V requires clip and cull distance be a single array of floats in all cases. This code provides input side conversion between the SPIR-V form and the HLSL form. (Output conversion was added in PR #947 and #997). This PR extends HlslParseContext::assignClipCullDistance to cope with the input side conversion. Not as much changed as appears: there was also a lot of renaming to reflect the fact that the code now handles either direction. Currently, non-{frag,vert} stages are not handled, and are explicitly rejected. Fixes #1026.
2017-08-23 18:34:42 +00:00
{"hlsl.clipdistance-5.frag", "main"},
WIP: HLSL: handle clip/cull distance array semantic matching In HLSL, there are three (TODO: ??) dimensions of clip and cull distance values: * The semantic's value N, ala SV_ClipDistanceN. * The array demension, if the value is an array. * The vector element, if the value is a vector or array of vectors. In SPIR-V, clip and cull distance are arrays of scalar floats, always. This PR currently ignores the semantic N axis, and handles the other two axes by sequentially copying each vector element of each array member into sequential floats in the output array. Fixes: #946
2017-06-22 18:08:00 +00:00
{"hlsl.clipdistance-5.vert", "main"},
HLSL: handle clip and cull distance input builtin type conversion HLSL allows a range of types for clip and cull distances. There are three dimensions, including arrayness, vectorness, and semantic ID. SPIR-V requires clip and cull distance be a single array of floats in all cases. This code provides input side conversion between the SPIR-V form and the HLSL form. (Output conversion was added in PR #947 and #997). This PR extends HlslParseContext::assignClipCullDistance to cope with the input side conversion. Not as much changed as appears: there was also a lot of renaming to reflect the fact that the code now handles either direction. Currently, non-{frag,vert} stages are not handled, and are explicitly rejected. Fixes #1026.
2017-08-23 18:34:42 +00:00
{"hlsl.clipdistance-6.frag", "main"},
HLSL: handle multiple clip/cull semantic IDs HLSL allows several variables to be declared. There are packing rules involved: e.g, a float3 and a float1 can be packed into a single array[4], while for a float3 and another float3, the second one will skip the third array entry to avoid straddling This is implements that ability. Because there can be multiple variables involved, and the final output array will often be a different type altogether (to fuse the values into a single destination), a new variable is synthesized, unlike the prior clip/cull support which used the declared variable. The new variable name is taken from one of the declared ones, so the old tests are unchanged. Several new tests are added to test various packing scenarios. Only two semantic IDs are supported: 0, and 1, per HLSL rules. This is encapsulated in static const int maxClipCullRegs = 2; and the algorithm (probably :) ) generalizes to larger values, although there are a few issues around how HLSL would pack (e.g, would 4 scalars be packed into a single HLSL float4 out reg? Probably, and this algorithm assumes so).
2017-07-05 17:33:06 +00:00
{"hlsl.clipdistance-6.vert", "main"},
HLSL: handle clip and cull distance input builtin type conversion HLSL allows a range of types for clip and cull distances. There are three dimensions, including arrayness, vectorness, and semantic ID. SPIR-V requires clip and cull distance be a single array of floats in all cases. This code provides input side conversion between the SPIR-V form and the HLSL form. (Output conversion was added in PR #947 and #997). This PR extends HlslParseContext::assignClipCullDistance to cope with the input side conversion. Not as much changed as appears: there was also a lot of renaming to reflect the fact that the code now handles either direction. Currently, non-{frag,vert} stages are not handled, and are explicitly rejected. Fixes #1026.
2017-08-23 18:34:42 +00:00
{"hlsl.clipdistance-7.frag", "main"},
HLSL: handle multiple clip/cull semantic IDs HLSL allows several variables to be declared. There are packing rules involved: e.g, a float3 and a float1 can be packed into a single array[4], while for a float3 and another float3, the second one will skip the third array entry to avoid straddling This is implements that ability. Because there can be multiple variables involved, and the final output array will often be a different type altogether (to fuse the values into a single destination), a new variable is synthesized, unlike the prior clip/cull support which used the declared variable. The new variable name is taken from one of the declared ones, so the old tests are unchanged. Several new tests are added to test various packing scenarios. Only two semantic IDs are supported: 0, and 1, per HLSL rules. This is encapsulated in static const int maxClipCullRegs = 2; and the algorithm (probably :) ) generalizes to larger values, although there are a few issues around how HLSL would pack (e.g, would 4 scalars be packed into a single HLSL float4 out reg? Probably, and this algorithm assumes so).
2017-07-05 17:33:06 +00:00
{"hlsl.clipdistance-7.vert", "main"},
HLSL: handle clip and cull distance input builtin type conversion HLSL allows a range of types for clip and cull distances. There are three dimensions, including arrayness, vectorness, and semantic ID. SPIR-V requires clip and cull distance be a single array of floats in all cases. This code provides input side conversion between the SPIR-V form and the HLSL form. (Output conversion was added in PR #947 and #997). This PR extends HlslParseContext::assignClipCullDistance to cope with the input side conversion. Not as much changed as appears: there was also a lot of renaming to reflect the fact that the code now handles either direction. Currently, non-{frag,vert} stages are not handled, and are explicitly rejected. Fixes #1026.
2017-08-23 18:34:42 +00:00
{"hlsl.clipdistance-8.frag", "main"},
HLSL: handle multiple clip/cull semantic IDs HLSL allows several variables to be declared. There are packing rules involved: e.g, a float3 and a float1 can be packed into a single array[4], while for a float3 and another float3, the second one will skip the third array entry to avoid straddling This is implements that ability. Because there can be multiple variables involved, and the final output array will often be a different type altogether (to fuse the values into a single destination), a new variable is synthesized, unlike the prior clip/cull support which used the declared variable. The new variable name is taken from one of the declared ones, so the old tests are unchanged. Several new tests are added to test various packing scenarios. Only two semantic IDs are supported: 0, and 1, per HLSL rules. This is encapsulated in static const int maxClipCullRegs = 2; and the algorithm (probably :) ) generalizes to larger values, although there are a few issues around how HLSL would pack (e.g, would 4 scalars be packed into a single HLSL float4 out reg? Probably, and this algorithm assumes so).
2017-07-05 17:33:06 +00:00
{"hlsl.clipdistance-8.vert", "main"},
HLSL: handle clip and cull distance input builtin type conversion HLSL allows a range of types for clip and cull distances. There are three dimensions, including arrayness, vectorness, and semantic ID. SPIR-V requires clip and cull distance be a single array of floats in all cases. This code provides input side conversion between the SPIR-V form and the HLSL form. (Output conversion was added in PR #947 and #997). This PR extends HlslParseContext::assignClipCullDistance to cope with the input side conversion. Not as much changed as appears: there was also a lot of renaming to reflect the fact that the code now handles either direction. Currently, non-{frag,vert} stages are not handled, and are explicitly rejected. Fixes #1026.
2017-08-23 18:34:42 +00:00
{"hlsl.clipdistance-9.frag", "main"},
HLSL: handle multiple clip/cull semantic IDs HLSL allows several variables to be declared. There are packing rules involved: e.g, a float3 and a float1 can be packed into a single array[4], while for a float3 and another float3, the second one will skip the third array entry to avoid straddling This is implements that ability. Because there can be multiple variables involved, and the final output array will often be a different type altogether (to fuse the values into a single destination), a new variable is synthesized, unlike the prior clip/cull support which used the declared variable. The new variable name is taken from one of the declared ones, so the old tests are unchanged. Several new tests are added to test various packing scenarios. Only two semantic IDs are supported: 0, and 1, per HLSL rules. This is encapsulated in static const int maxClipCullRegs = 2; and the algorithm (probably :) ) generalizes to larger values, although there are a few issues around how HLSL would pack (e.g, would 4 scalars be packed into a single HLSL float4 out reg? Probably, and this algorithm assumes so).
2017-07-05 17:33:06 +00:00
{"hlsl.clipdistance-9.vert", "main"},
HLSL: Enable component-wise vector comparisons from operators This PR only changes a few lines of code, but is subtle. In HLSL, comparison operators (<,>,<=,>=,==,!=) operate component-wise when given a vector operand. If a whole vector equality or inequality is desired, then all() or any() can be used on the resulting bool vector. This PR enables this change. Existing shape conversion is used when one of the two arguments is a vector and one is a scalar. Some existing HLSL tests had assumed == and != meant vector-wise instead of component-wise comparisons. These tests have been changed to add an explicit any() or all() to the test source. This verifably does not change the final SPIR-V binary relative to the old behavior for == and !=. The AST does change for the (now explicit, formerly implicit) any() and all(). Also, a few tests changes where they previously had the return type wrong, e.g, from a vec < vec comparison in hlsl.shapeConv.frag. Promotion of comparison opcodes to vector forms (EOpEqual->EOpVectorEqual) is handled in promoteBinary(), as is setting the proper vector type of the result. EOpVectorEqual and EOpVectorNotEqual are now accepted as either aggregate or binary nodes, similar to how the other operators are handled. Partial support already existed for this: it has been fleshed out in the printing functions in intermOut.cpp. There is an existing defect around shape conversion with 1-vectors, but that is orthogonal to this PR and not addressed by it.
2016-10-21 22:43:38 +00:00
{"hlsl.comparison.vec.frag", "main"},
HLSL: Implement ?: grammar productions. Missing are implicit conversions between int/bool/etc.
2016-07-27 16:39:57 +00:00
{"hlsl.conditional.frag", "PixelShaderFunction"},
HLSL: Add ConstantBuffer<T> syntax Note: multi-dimension arrays of ConstantBuffer objects will go through uniform flattening.
2017-04-25 15:30:28 +00:00
{"hlsl.constantbuffer.frag", "main"},
HLSL: Fix #924: Convert between two different arrays with cast.
2017-06-14 05:13:10 +00:00
{"hlsl.constructArray.vert", "main"},
HLSL: Fix a grammar error related to constructors in parenthetical expressions
2016-07-30 13:38:55 +00:00
{"hlsl.constructexpr.frag", "main"},
HLSL: Add imat, umat, and bmat constructors Fixes #894
2017-05-21 03:40:27 +00:00
{"hlsl.constructimat.frag", "main"},
HLSL: Handle greater/less depth modes. Fixes issue #489.
2016-09-03 02:05:19 +00:00
{"hlsl.depthGreater.frag", "PixelShaderFunction"},
{"hlsl.depthLess.frag", "PixelShaderFunction"},
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
{"hlsl.discard.frag", "PixelShaderFunction"},
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
{"hlsl.doLoop.frag", "PixelShaderFunction"},
HLSL: fix crash on empty struct return from entry point
2017-03-24 14:56:37 +00:00
{"hlsl.emptystructreturn.frag", "main"},
{"hlsl.emptystructreturn.vert", "main"},
HLSL: Allow empty struct initializers Review request: does this harm GLSL in any way?
2017-04-28 00:22:52 +00:00
{"hlsl.emptystruct.init.vert", "main"},
HLSL: Handle flatten for reads from flatten structs and parameter passing.
2016-09-17 01:44:00 +00:00
{"hlsl.entry-in.frag", "PixelShaderFunction"},
HLSL: Emulate write-to-output on return-from-entry-point, for return value. This fixes issue #487 and #480. It also correctly handles output parameters from the entry point.
2016-08-28 21:00:23 +00:00
{"hlsl.entry-out.frag", "PixelShaderFunction"},
HLSL: allow GS-specific methods in other stages Using GS methods such as Append() in non-GS stages should be ignored, but was creating errors due to the lack of a stream output symbol for the non-GS stage.
2017-05-13 15:20:11 +00:00
{"hlsl.fraggeom.frag", "main"},
Full stack: distinguish between a scalar and a vector of size 1. There have been GLSL extensions considering this, and HLSL does it. This is a fully backward compatible change that allows this distinction.
2016-05-20 18:06:03 +00:00
{"hlsl.float1.frag", "PixelShaderFunction"},
Tests: Add a set of gtest-file-based HLSL tests.
2016-05-16 23:39:50 +00:00
{"hlsl.float4.frag", "PixelShaderFunction"},
HLSL: fix for flattening assignments from non-symbol R-values. If a member-wise assignment from a non-flattened struct to a flattened struct sees a complex R-value (not a symbol), it now creates a temporary to hold that value, to avoid repeating the R-value. This avoids, e.g, duplicating a whole function call. Also, it avoids re-using the AST node, making a new one for each member inside the member loop. The latter (re-use of AST node) was also an issue in the GetDimensions intrinsic decomposition, so this PR fixes that one too.
2016-10-03 04:13:22 +00:00
{"hlsl.flatten.return.frag", "main"},
SPV: When passing structs of opaque types, flatten and pass the members instead. This avoids either A) needing uniformConstant struct, or B) initializing a struct with opaque members, as writing them is not allowed.
2017-05-26 06:01:36 +00:00
{"hlsl.flattenOpaque.frag", "main"},
Fix #980: flatten opaque initializers to use aliases.
2017-07-16 11:46:13 +00:00
{"hlsl.flattenOpaqueInit.vert", "main"},
{"hlsl.flattenOpaqueInitMix.vert", "main"},
HLSL: Fix #954: Track/access subsets of flattened multi-level aggregates. Works in conjuction with d1be754 to represent and modify a partially dereferenced multi-level flattened aggregate.
2017-10-04 19:27:43 +00:00
{"hlsl.flattenSubset.frag", "main"},
{"hlsl.flattenSubset2.frag", "main"},
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
{"hlsl.forLoop.frag", "PixelShaderFunction"},
HLSL: Add gather, improve proto generator machine for upcoming 2DMS/Shadow
2016-07-22 14:28:11 +00:00
{"hlsl.gather.array.dx10.frag", "main"},
{"hlsl.gather.basic.dx10.frag", "main"},
{"hlsl.gather.basic.dx10.vert", "main"},
{"hlsl.gather.offset.dx10.frag", "main"},
{"hlsl.gather.offsetarray.dx10.frag", "main"},
Enable GatherCmpRed. Green/Blue/Alpha cannot be supported. This implements GatherCmpRed in terms of OpImageDrefGather. There appears to be no way to implement the Green/Blue/Apha forms: see #673.
2017-03-09 15:59:45 +00:00
{"hlsl.gathercmpRGBA.offset.dx10.frag", "main"},
HLSL: Add GatherRed/Green/Blue/Alpha methods, inc 4-offset forms
2016-07-31 16:37:02 +00:00
{"hlsl.gatherRGBA.array.dx10.frag", "main"},
{"hlsl.gatherRGBA.basic.dx10.frag", "main"},
{"hlsl.gatherRGBA.offset.dx10.frag", "main"},
{"hlsl.gatherRGBA.offsetarray.dx10.frag", "main"},
HLSL: Add tx.GetDimensions method (uint returns only)
2016-07-15 17:22:24 +00:00
{"hlsl.getdimensions.dx10.frag", "main"},
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
{"hlsl.getdimensions.rw.dx10.frag", "main"},
HLSL: Add tx.GetDimensions method (uint returns only)
2016-07-15 17:22:24 +00:00
{"hlsl.getdimensions.dx10.vert", "main"},
HLSL: Add CalculateLevelOfDetail, and unimplemented errors for *Unclamped and GetSamplePosition
2016-07-26 14:57:53 +00:00
{"hlsl.getsampleposition.dx10.frag", "main"},
WIP: HLSL: support global const initializers from non-constant rvalues Semantic test left over from other source languages is removed, since this is permitted by HLSL. Also, to support the functionality, a targeted test is performed for this case and it is turned into a EvqGlobal qualifier to create an AST initialization segment when needed. Constness is now propagated up aggregate chains during initializer construction. This handles hierarchical cases such as the distinction between: static const float2 a[2] = { { 1, 2 }, { 3, 4} }; vs static const float2 a[2] = { { 1, 2 }, { cbuffer_member, 4} }; The first of which can use a first class constant initalization, and the second cannot.
2017-07-10 21:43:40 +00:00
{"hlsl.global-const-init.frag", "main"},
HLSL: pass tessellation execution modes through to SPIR-V The SPIR-V generator had assumed tessellation modes such as primitive type and vertex order would only appear in tess eval (domain) shaders. SPIR-V allows either, and HLSL allows and possibly requires them to be in the hull shader. This change: 1. Passes them through for either tessellation stage, and, 2. Does not set up defaults in the domain stage for HLSl compilation, to avoid conflicting definitions.
2017-03-23 17:56:07 +00:00
{"hlsl.domain.1.tese", "main"},
HLSL: handle PCF input to DS in arbitrary argument position In the hull shader, the PCF output does not participate in an argument list, so has no defined ordering. It is always put at the end of the linkage. That means the DS input reading PCF data must be be at the end of the DS linkage as well, no matter where it may appear in the argument list. This change makes sure that happens. The detection is by looking for arguments that contain tessellation factor builtins, even as a struct member. The whole struct is taken as the PCF output if any members are so qualified.
2017-04-03 15:27:53 +00:00
{"hlsl.domain.2.tese", "main"},
HLSL: allow non-vec3 tessellation coordinate declarations HLSL requires vec2 tessellation coordinate declarations in some cases (e.g, isoline topology), where SPIR-V requires the TessCoord qualified builtin to be a vec3 in all cases. This alters the IO form of the variable to be a vec3, which will be copied to the shader's declared type if needed. This is not a validation; the shader type must be correct.
2017-04-05 17:03:02 +00:00
{"hlsl.domain.3.tese", "main"},
HLSL: Fix #902: Incorrect protection against zero arguments.
2017-05-24 22:02:56 +00:00
{"hlsl.function.frag", "main"},
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
{"hlsl.hull.1.tesc", "main"},
{"hlsl.hull.2.tesc", "main"},
HLSL: support point mode.
2017-06-26 23:52:22 +00:00
{"hlsl.hull.3.tesc", "main"},
HLSL: allow mixed user & builtin members in hull shader output structure Hull shaders have an implicitly arrayed output. This is handled by creating an arrayed form of the provided output type, and writing to the element of it indexed by InvocationID. The implicit indirection into that array was causing some troubles when copying to a split structure. handleAssign was able to handle simple symbol lvalues, but not an lvalue composed of an indirection into an array.
2017-09-10 15:46:55 +00:00
{"hlsl.hull.4.tesc", "main"},
HLSL: handle split InputPatch templat type in patch constant functions InputPatch parameters to patch constant functions were not using the internal (temporary) variable type. That could cause validation errors if the input patch had a mixture of builtins and user qualified members. This uses the entry point's internal form. There is currently a limitation: if an InputPatch is used in a PCF, it must also have appeared in the main entry point's parameter list. That is not a limitation of HLSL. Currently that situation is detected and an "implemented" error results. The limitation can be addressed, but isn't yet in the current form of the PR.
2017-09-13 14:44:39 +00:00
{"hlsl.hull.5.tesc", "main"},
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
{"hlsl.hull.void.tesc", "main"},
HLSL: support per control point patch const fn invocation This PR emulates per control point inputs to patch constant functions. Without either an extension to look across SIMD lanes or a dedicated stage, the emulation must use separate invocations of the wrapped entry point to obtain the per control point values. This is provided since shaders are wanting this functionality now, but such an extension is not yet available. Entry point arguments qualified as an invocation ID are replaced by the current control point number when calling the wrapped entry point. There is no particular optimization for the case of the entry point not having such an input but the PCF still accepting ctrl pt frequency data. It'll work, but anyway makes no so much sense. The wrapped entry point must return the per control point data by value. At this time it is not supported as an output parameter.
2017-03-14 23:37:10 +00:00
{"hlsl.hull.ctrlpt-1.tesc", "main"},
WIP: HLSL: Support InputPatch variables in patch constant functions Previously, patch constant functions only accepted OutputPatch. This adds InputPatch support, via a pseudo-builtin variable type, so that the patch can be tracked clear through from the qualifier.
2017-04-01 21:34:48 +00:00
{"hlsl.hull.ctrlpt-2.tesc", "main"},
HLSL: allow "sample" as a valid identifier. HLSL has keywords for various interpolation modifiers such as "linear", "centroid", "sample", etc. Of these, "sample" appears to be special, as it is also accepted as an identifier string, where the others are not. This PR adds this ability, so the construct "int sample = 42;" no longer produces a compilation error. New test = hlsl.identifier.sample.frag
2016-11-16 20:22:11 +00:00
{"hlsl.identifier.sample.frag", "main"},
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
{"hlsl.if.frag", "PixelShaderFunction"},
HLSL: Implicit bool conversions for conditional expressions and related. Covers if(cond), while(cond), do-while(cond), for(;cond;), and (cond ? :). Fixes #778.
2017-03-31 04:09:30 +00:00
{"hlsl.implicitBool.frag", "main"},
HLSL: Support 1.#INF and -1.#INF syntax.
2017-04-12 19:26:57 +00:00
{"hlsl.inf.vert", "main"},
HLSL: add in/out/inout qualifiers.
2016-07-13 02:44:32 +00:00
{"hlsl.inoutquals.frag", "main"},
HLSL: Grammar: Make comma-separated declaration lists work.
2016-07-02 01:06:44 +00:00
{"hlsl.init.frag", "ShaderFunction"},
HLSL: allow trailing commas in initializer lists & scalar initialization
2016-07-30 16:36:09 +00:00
{"hlsl.init2.frag", "main"},
Decompose OpIsFinite to avoid capability restrictions OpIsFinite is not available everywhere: decompose isfinite to !isinf && !isnan.
2017-04-04 02:05:21 +00:00
{"hlsl.isfinite.frag", "main"},
Add HLSL memory barrier intrinsics, fix dst, add lit & EvaluateAttributeSnapped
2016-06-15 15:50:24 +00:00
{"hlsl.intrinsics.barriers.comp", "ComputeShaderFunction"},
Implement atomic ops, bit conversions, fix fwidth stage mask, fix saturate dest modifier.
2016-06-13 15:22:28 +00:00
{"hlsl.intrinsics.comp", "ComputeShaderFunction"},
Add HLSL memory barrier intrinsics, fix dst, add lit & EvaluateAttributeSnapped
2016-06-15 15:50:24 +00:00
{"hlsl.intrinsics.evalfns.frag", "main"},
Add EOpD3DCOLORtoUBYTE4 decomposition
2017-01-03 21:42:18 +00:00
{"hlsl.intrinsics.d3dcolortoubyte4.frag", "main"},
Add asdouble, fma, & mad intrinsics and change profile to allow doubles when parsing prototypes
2016-06-22 21:20:14 +00:00
{"hlsl.intrinsics.double.frag", "PixelShaderFunction"},
WIP: HLSL: add f16tof32 and f32tof16 decompositions.
2017-02-27 20:09:32 +00:00
{"hlsl.intrinsics.f1632.frag", "main"},
{"hlsl.intrinsics.f3216.frag", "main"},
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
{"hlsl.intrinsics.frag", "main"},
HLSL: Move frexp() to a separate test file.
2017-03-29 09:04:58 +00:00
{"hlsl.intrinsic.frexp.frag", "main"},
Add HLSL memory barrier intrinsics, fix dst, add lit & EvaluateAttributeSnapped
2016-06-15 15:50:24 +00:00
{"hlsl.intrinsics.lit.frag", "PixelShaderFunction"},
Implement atomic ops, bit conversions, fix fwidth stage mask, fix saturate dest modifier.
2016-06-13 15:22:28 +00:00
{"hlsl.intrinsics.negative.comp", "ComputeShaderFunction"},
Add negative intrinsics tests
2016-06-03 16:53:28 +00:00
{"hlsl.intrinsics.negative.frag", "PixelShaderFunction"},
{"hlsl.intrinsics.negative.vert", "VertexShaderFunction"},
HLSL: add intrinsic function implicit promotions This PR handles implicit promotions for intrinsics when there is no exact match, such as for example clamp(int, bool, float). In this case the int and bool will be promoted to a float, and the clamp(float, float, float) form used. These promotions can be mixed with shape conversions, e.g, clamp(int, bool2, float2). Output conversions are handled either via the existing addOutputArgumentConversion function, which this PR generalizes to handle either aggregates or unaries, or by intrinsic decomposition. If there are methods or intrinsics to be decomposed, then decomposition is responsible for any output conversions, which turns out to happen automatically in all current cases. This can be revisited once inout conversions are in place. Some cases of actual ambiguity were fixed in several tests, e.g, spv.register.autoassign.* Some intrinsics with only uint versions were expanded to signed ints natively, where the underlying AST and SPIR-V supports that. E.g, countbits. This avoids extraneous conversion nodes. A new function promoteAggregate is added, and used by findFunction. This is essentially a generalization of the "promote 1st or 2nd arg" algorithm in promoteBinary. The actual selection proceeds in three steps, as described in the comments in hlslParseContext::findFunction: 1. Attempt an exact match. If found, use it. 2. If not, obtain the operator from step 1, and promote arguments. 3. Re-select the intrinsic overload from the results of step 2.
2016-11-02 18:42:34 +00:00
{"hlsl.intrinsics.promote.frag", "main"},
{"hlsl.intrinsics.promote.down.frag", "main"},
{"hlsl.intrinsics.promote.outputs.frag", "main"},
HLSL: Partially address issue #463: accept GLSL layout(...). This includes all "per variable" layout qualifiers, but the key ones mattering and tested for now are: set= binding= constant_id= push_constant
2016-08-17 16:22:08 +00:00
{"hlsl.layout.frag", "main"},
HLSL: add 2DMS texture formats, and matching Load / GetDimensions support
2016-07-26 21:19:28 +00:00
{"hlsl.load.2dms.dx10.frag", "main"},
HLSL: Add texture Load method & decomposition
2016-07-20 22:34:44 +00:00
{"hlsl.load.array.dx10.frag", "main"},
{"hlsl.load.basic.dx10.frag", "main"},
HLSL: add 2DMS texture formats, and matching Load / GetDimensions support
2016-07-26 21:19:28 +00:00
{"hlsl.load.basic.dx10.vert", "main"},
HLSL: add Buffer support for Load method
2016-07-27 21:46:48 +00:00
{"hlsl.load.buffer.dx10.frag", "main"},
HLSL: phase 3a: Add sub-vec4 rwtexture formats (qualifier.layoutFormat) This PR sets the TQualifier layoutFormat according to the HLSL image type. For instance: RWTexture1D <float2> g_tTex1df2; becomes ElfRg32f. Similar on Buffers, e.g, Buffer<float4> mybuffer; The return type for image and buffer loads is now taken from the storage format. Also, the qualifier for the return type is now (properly) a temp, not a global.
2016-10-10 21:24:57 +00:00
{"hlsl.load.buffer.float.dx10.frag", "main"},
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
{"hlsl.load.rwbuffer.dx10.frag", "main"},
{"hlsl.load.rwtexture.dx10.frag", "main"},
{"hlsl.load.rwtexture.array.dx10.frag", "main"},
HLSL: Add texture Load method & decomposition
2016-07-20 22:34:44 +00:00
{"hlsl.load.offset.dx10.frag", "main"},
{"hlsl.load.offsetarray.dx10.frag", "main"},
Added test for local structured buffer variable
2017-10-06 22:47:54 +00:00
{"hlsl.localStructuredBuffer.comp", "main"},
HLSL: Fix unary and binary operator type conversion issues This fixes defects as follows: 1. handleLvalue could be called on a non-L-value, and it shouldn't be. 2. HLSL allows unary negation on non-bool values. TUnaryOperator::promote can now promote other types (e.g, int, float) to bool for this op. 3. HLSL allows binary logical operations (&&, ||) on arbitrary types, similar (2). 4. HLSL allows mod operation on arbitrary types, which will be promoted. E.g, int % float -> float % float.
2016-10-15 16:29:58 +00:00
{"hlsl.logical.binary.frag", "main"},
HLSL: allow component-wise operations for logical || and &&. HLSL || and && can operate component-wise.
2016-10-26 18:42:49 +00:00
{"hlsl.logical.binary.vec.frag", "main"},
HLSL: Fix #802: Preserve promoted child under ! operator.
2017-03-31 05:32:21 +00:00
{"hlsl.logicalConvert.frag", "main"},
{"hlsl.logical.unary.frag", "main"},
HLSL: implement [unroll] and [loop] attributes This adds infrastructure suitable for any front end to create SPIR-V loop control flags. The only current front end doing so is HLSL. [unroll] turns into spv::LoopControlUnrollMask [loop] turns into spv::LoopControlDontUnrollMask no specification means spv::LoopControlMaskNone
2017-05-03 02:14:50 +00:00
{"hlsl.loopattr.frag", "main"},
HLSL: implement #pragma pack_matrix(layout) This adds support for #pragma pack_matrix() to the HLSL front end. The pragma sets the default matrix layout for subsequent unqualified matrices in structs or buffers. Explicit qualification overrides the pragma value. Matrix layout is not permitted at the structure level in HLSL, so only leaves which are matrix types can be so qualified. Note that due to the semantic (not layout) difference in first matrix indirections between HLSL and SPIR-V, the sense of row and column major are flipped. That's independent of this PR: just a factor to note. A column_major qualifier appears as a RowMajor member decoration in SPIR-V modules, and vice versa.
2017-08-07 18:08:50 +00:00
{"hlsl.matpack-pragma.frag", "main"},
HLSL: add .mips[][] operator for texture types This implements mytex.mips[mip][coord] for texture types. There is some error testing, but not comprehensive. The constructs can be nested, e.g in this case the inner .mips is parsed before the completion of the outer [][] operator. tx.mips[tx.mips[a][b].x][c]
2017-05-12 23:14:31 +00:00
{"hlsl.mip.operator.frag", "main"},
{"hlsl.mip.negative.frag", "main"},
{"hlsl.mip.negative2.frag", "main"},
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
{"hlsl.namespace.frag", "main"},
HLSL: cast bracket dereference index to int type if not. HLSL can index arrays using operator[] with non-integer types, and inserts a conversion to a uint if needed.
2017-04-07 02:22:20 +00:00
{"hlsl.nonint-index.frag", "main"},
HLSL: use HLSL parser to parse HLSL intrinsic prototypes, enable int/bool mats This PR adds a CreateParseContext() fn analogous to CreateBuiltInParseables(), to create a language specific built in parser. (This code was present before but not encapsualted in a fn). This can now be used to create a source language specific parser for builtins. Along with this, the code creating HLSL intrinsic prototypes can now produce them in HLSL syntax, rather than GLSL syntax. This relaxes certain prior restrictions at the parser level. Lower layers (e.g, SPIR-V) may still have such restrictions, such as around Nx1 matrices: this code does not impact that. This PR also fleshes out matrix types for bools and ints, both of which were partially in place before. This was easier than maintaining the restrictions in the HLSL prototype generator to avoid creating protoypes with those types. Many tests change because the result type from intrinsics moves from "global" to "temp". Several new tests are added for the new types.
2016-11-15 17:11:04 +00:00
{"hlsl.matNx1.frag", "main"},
HLSL: fix qualifier propagation from user struct types to block definitions. The HLSL FE tracks four versions of a declared type to avoid losing information, since it is not (at type-decl time) known how the type will be used downstream. If such a type was used in a cbuffer declaration, the cbuffer type's members should have been using the uniform form of the original user structure type, but were not. This would manifest as matrix qualifiers (and other things, such as pack offsets) on user struct members going missing in the SPIR-V module if the struct type was a member of a cbuffer, like so: struct MyBuffer { row_major float4x4 mat1; column_major float4x4 mat2; }; cbuffer Example { MyBuffer g_MyBuffer; }; Fixes: #789
2017-08-04 21:40:53 +00:00
{"hlsl.matpack-1.frag", "main"},
HLSL: matrix swizzle (_12, _m23) syntax, partial semantics. This partially addressess issue #670, for when the matrix swizzle degenerates to a component or column: m[c], m[c][r] (where HLSL swaps rows and columns for user's view). An error message is given for the arbitrary cases not covered. These cases will work for arbitrary use of l-values. Future work will handle more arbitrary swizzles, which might not work as arbitrary l-values.
2017-01-12 23:51:18 +00:00
{"hlsl.matrixSwizzle.vert", "ShaderFunction"},
HLSL: Implement member functions calling member functions.
2017-05-17 05:16:26 +00:00
{"hlsl.memberFunCall.frag", "main"},
HLSL: Add min*{float,int,uint} types These HLSL types are guaranteed to have at least the given number of bits, but may have more. min{16,10}float is mapped to EbtFloat at medium precision -> SPIRV RelaxedPrecision min{16,12}int and min16uint are mapped to mediump -> SPIR-V RelaxedPrecision
2016-10-27 01:18:55 +00:00
{"hlsl.mintypes.frag", "main"},
HLSL: Handle "fake" entry points, by undoing their built-in variable declarations.
2016-09-03 02:23:27 +00:00
{"hlsl.multiEntry.vert", "RealEntrypoint"},
HLSL: Do structure conversion for return type struct-punning on non-entry-point functions.
2016-10-06 18:59:51 +00:00
{"hlsl.multiReturn.frag", "main"},
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
{"hlsl.matrixindex.frag", "main"},
HLSL: Basic turn on of non-static member functions. Still need: pass by reference in SPIR-V and symbol-table level for accessing 'this' members from member functions.
2017-03-20 00:09:59 +00:00
{"hlsl.nonstaticMemberFunction.frag", "main"},
HLSL: allow uint literals, and add test for numeric suffixes
2016-07-28 20:49:48 +00:00
{"hlsl.numericsuffixes.frag", "main"},
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
{"hlsl.numthreads.comp", "main_aux1"},
HLSL: Switch to generic selector, but using GLSL #version 400 rules. Next step is to modify for HLSL rules.
2016-08-25 00:34:43 +00:00
{"hlsl.overload.frag", "PixelShaderFunction"},
Fix lvalue check in SPIR-V generation There were several locations in TGlslangToSpvTraverser::handleUserFunctionCall testing for whether a fn argument should be in the lvalue or rvalue array. They must get the same result for indexing sanity, but had slightly different logic. They're now forced into the same test.
2017-09-06 20:59:06 +00:00
{"hlsl.opaque-type-bug.frag", "main"},
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
{"hlsl.params.default.frag", "main"},
{"hlsl.params.default.negative.frag", "main"},
HLSL: Support {...} initializer lists that are too short.
2016-11-28 00:39:07 +00:00
{"hlsl.partialInit.frag", "PixelShaderFunction"},
HLSL: Partially flatten hierarchies, instead of all or nothing. Fixes #1092. Allows arrays of opaques to keep arrayness, unless needed by uniform array flattening. Can handle assignments of mixed amounts of flattening.
2017-10-11 20:03:45 +00:00
{"hlsl.partialFlattenLocal.vert", "main"},
HLSL: Allow macro expansions to create the 'defined' operator.
2017-06-08 23:12:56 +00:00
{"hlsl.pp.vert", "main"},
HLSL: enable #line extension by default for HLSL source.
2016-07-23 02:46:03 +00:00
{"hlsl.pp.line.frag", "main"},
HLSL: add precise keyword
2016-08-25 05:49:36 +00:00
{"hlsl.precise.frag", "main"},
HLSL: opcode specific promotion rules for interlocked ops PR #577 addresses most but not all of the intrinsic promotion problems. This PR resolves all known cases in the remainder. Interlocked ops need special promotion rules because at the time of function selection, the first argument has not been converted to a buffer object. It's just an int or uint, but you don't want to convert THAT argument, because that implies converting the buffer object itself. Rather, you can convert other arguments, but want to stay in the same "family" of functions. E.g, if the first interlocked arg is a uint, use only the uint family, never the int family, you can convert the other args as you please. This PR allows making such opcode and arg specific choices by passing the op and arg to the convertible lambda. The code in the new test "hlsl.promote.atomic.frag" would not compile without this change, but it must compile. Also, it provides better handling of downconversions (to "worse" types), which are permitted in HLSL. The existing method of selecting upconversions is unchanged, but if that doesn't find any valid ones, then it will allow downconversions. In effect this always uses an upconversion if there is one.
2016-12-06 22:50:11 +00:00
{"hlsl.promote.atomic.frag", "main"},
HLSL: Fix unary and binary operator type conversion issues This fixes defects as follows: 1. handleLvalue could be called on a non-L-value, and it shouldn't be. 2. HLSL allows unary negation on non-bool values. TUnaryOperator::promote can now promote other types (e.g, int, float) to bool for this op. 3. HLSL allows binary logical operations (&&, ||) on arbitrary types, similar (2). 4. HLSL allows mod operation on arbitrary types, which will be promoted. E.g, int % float -> float % float.
2016-10-15 16:29:58 +00:00
{"hlsl.promote.binary.frag", "main"},
HLSL: allow promotion from 1-vector types to scalars, e.g, float<-float1 Previously, an error was thrown when assigning a float1 to a scalar float, or similar for other basic types. This allows that. Also, this allows calling functions accepting scalars with float1 params, so for example sin(float1) will work. This is a minor change in HlslParseContext::findFunction().
2016-11-11 22:37:10 +00:00
{"hlsl.promote.vec1.frag", "main"},
HLSL: add implicit promotions for assignments and function returns.
2016-08-09 17:28:03 +00:00
{"hlsl.promotions.frag", "main"},
HLSL: phase 4 of rwtexture support: add image atomics This PR will turn Interlocked* intrinsics using rwtexture or rwbuffer object as the first parameter into the proper OpImageAtomic* operations.
2016-10-19 16:15:25 +00:00
{"hlsl.rw.atomics.frag", "main"},
HLSL: phase 2a: add r-value operator[] for RWTexture/RWBuffer This commit adds r-value support for RW textures and buffers. Supported is: - Function in parameter conversions - conversion of rvalue use to imageLoad
2016-10-07 02:12:24 +00:00
{"hlsl.rw.bracket.frag", "main"},
Add UAV (image) binding offset and HLSL register support This PR adds: 1. The "u" register class for RW* objects. 2. --shift-image-bindings (== --sib), analogous to --shift-texture-bindings etc. 3. Case insensitive reg classes. 4. Tests for above.
2016-11-01 16:31:42 +00:00
{"hlsl.rw.register.frag", "main"},
HLSL: phase 3a: Add sub-vec4 rwtexture formats (qualifier.layoutFormat) This PR sets the TQualifier layoutFormat according to the HLSL image type. For instance: RWTexture1D <float2> g_tTex1df2; becomes ElfRg32f. Similar on Buffers, e.g, Buffer<float4> mybuffer; The return type for image and buffer loads is now taken from the storage format. Also, the qualifier for the return type is now (properly) a temp, not a global.
2016-10-10 21:24:57 +00:00
{"hlsl.rw.scalar.bracket.frag", "main"},
HLSL: allow destination swizzles when writing RWTexture/RWBuffer objects. Reads and write syntax to UAV objects is turned into EOpImageLoad/Store operations. This translation did not support destination swizzles, for example, "mybuffer[tc].zyx = 3;", so such statements would fail to compile. Now they work. Parial updates are explicitly prohibited. New test: hlsl.rw.swizzle.frag
2016-12-28 17:03:58 +00:00
{"hlsl.rw.swizzle.frag", "main"},
HLSL: phase 3a: Add sub-vec4 rwtexture formats (qualifier.layoutFormat) This PR sets the TQualifier layoutFormat according to the HLSL image type. For instance: RWTexture1D <float2> g_tTex1df2; becomes ElfRg32f. Similar on Buffers, e.g, Buffer<float4> mybuffer; The return type for image and buffer loads is now taken from the storage format. Also, the qualifier for the return type is now (properly) a temp, not a global.
2016-10-10 21:24:57 +00:00
{"hlsl.rw.vec2.bracket.frag", "main"},
HLSL: Add SampleBias and SampleGrad, and associated tests
2016-07-14 20:45:14 +00:00
{"hlsl.sample.array.dx10.frag", "main"},
{"hlsl.sample.basic.dx10.frag", "main"},
{"hlsl.sample.offset.dx10.frag", "main"},
{"hlsl.sample.offsetarray.dx10.frag", "main"},
{"hlsl.samplebias.array.dx10.frag", "main"},
{"hlsl.samplebias.basic.dx10.frag", "main"},
{"hlsl.samplebias.offset.dx10.frag", "main"},
{"hlsl.samplebias.offsetarray.dx10.frag", "main"},
HLSL: Add SampleCmp and SampleCmpLevelZero texture methods
2016-07-19 20:28:05 +00:00
{"hlsl.samplecmp.array.dx10.frag", "main"},
{"hlsl.samplecmp.basic.dx10.frag", "main"},
HLSL: split textures used for both shadow and non-shadow modes A single texture can statically appear in code mixed with a shadow sampler and a non-shadow sampler. This would be create invalid SPIR-V, unless one of them is provably dead. The previous detection of this happened before DCE, so some shaders would trigger the error even though they wouldn't after DCE. To handle that case, this PR splits the texture into two: one with each mode. It sets "needsLegalization" (if that happens for any texture) to warn that this shader will need post-compilation legalization. If the texture is only used with one of the two modes, behavior is as it was before.
2017-10-05 22:25:52 +00:00
{"hlsl.samplecmp.dualmode.frag", "main"},
HLSL: Add SampleCmp and SampleCmpLevelZero texture methods
2016-07-19 20:28:05 +00:00
{"hlsl.samplecmp.offset.dx10.frag", "main"},
{"hlsl.samplecmp.offsetarray.dx10.frag", "main"},
HLSL: add error for expected comparison sampler in SampleCmp* ops This adds an error message if a non-comparison sampler is used with comparison sampling methods. There's no functional change for correct shaders.
2017-04-21 15:54:53 +00:00
{"hlsl.samplecmp.negative.frag", "main"},
{"hlsl.samplecmp.negative2.frag", "main"},
HLSL: Add SampleCmp and SampleCmpLevelZero texture methods
2016-07-19 20:28:05 +00:00
{"hlsl.samplecmplevelzero.array.dx10.frag", "main"},
{"hlsl.samplecmplevelzero.basic.dx10.frag", "main"},
{"hlsl.samplecmplevelzero.offset.dx10.frag", "main"},
{"hlsl.samplecmplevelzero.offsetarray.dx10.frag", "main"},
HLSL: Add SampleBias and SampleGrad, and associated tests
2016-07-14 20:45:14 +00:00
{"hlsl.samplegrad.array.dx10.frag", "main"},
{"hlsl.samplegrad.basic.dx10.frag", "main"},
{"hlsl.samplegrad.basic.dx10.vert", "main"},
{"hlsl.samplegrad.offset.dx10.frag", "main"},
{"hlsl.samplegrad.offsetarray.dx10.frag", "main"},
HLSL: Add SampleLevel method
2016-07-21 21:02:16 +00:00
{"hlsl.samplelevel.array.dx10.frag", "main"},
{"hlsl.samplelevel.basic.dx10.frag", "main"},
{"hlsl.samplelevel.basic.dx10.vert", "main"},
{"hlsl.samplelevel.offset.dx10.frag", "main"},
{"hlsl.samplelevel.offsetarray.dx10.frag", "main"},
HLSL: Fix unary and binary operator type conversion issues This fixes defects as follows: 1. handleLvalue could be called on a non-L-value, and it shouldn't be. 2. HLSL allows unary negation on non-bool values. TUnaryOperator::promote can now promote other types (e.g, int, float) to bool for this op. 3. HLSL allows binary logical operations (&&, ||) on arbitrary types, similar (2). 4. HLSL allows mod operation on arbitrary types, which will be promoted. E.g, int % float -> float % float.
2016-10-15 16:29:58 +00:00
{"hlsl.sample.sub-vec4.dx10.frag", "main"},
HLSL: allow length() on scalars
2017-03-24 16:12:53 +00:00
{"hlsl.scalar-length.frag", "main"},
HLSL: Fix #805: Support cast of scalars to structures. Somewhat complex due to recognizing a general scalar, but not replicating it for each member to avoid side effects.
2017-04-04 17:47:42 +00:00
{"hlsl.scalarCast.vert", "main"},
HLSL: allow semicolons between global scope declarations.
2016-08-03 13:04:18 +00:00
{"hlsl.semicolons.frag", "main"},
HLSL: Add shape conversions for scalar -> vector assigments. Also, this allows turning on the error check for a failed assigment when parsing. This makes 39 HLSL tests have a working assignment that was previously silently dropped, due to lack of this functionality.
2016-07-28 23:53:56 +00:00
{"hlsl.shapeConv.frag", "main"},
HLSL: Add shape conversions for return values.
2016-10-06 22:56:54 +00:00
{"hlsl.shapeConvRet.frag", "main"},
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
{"hlsl.staticMemberFunction.frag", "main"},
HLSL: Add EHTokStringConstant, so that string attributes may be parsed
2016-08-22 22:13:47 +00:00
{"hlsl.stringtoken.frag", "main"},
HLSL: Add string basic type and recognize string declaration grammar. This includes the "< decl ; decl ; >" syntax which has its own namespace. This functionality is not implemented, just silently accepted.
2016-09-20 02:23:18 +00:00
{"hlsl.string.frag", "main"},
HLSL: inter-stage structure splitting. This adds structure splitting, which among other things will enable GS support where input structs are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case. The salient points of this PR are: * Structure splitting has been changed from "always between stages" to "only into the VS and out of the PS". It had previously happened between stages because it's not legal to pass a struct containing a builtin IO variable. * Structs passed between stages are now split into a struct containing ONLY user types, and a collection of loose builtin IO variables, if any. The user-part is passed as a normal struct between stages, which is valid SPIR-V now that the builtin IO is removed. * Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g, functions can work unmodified. * If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS, the array reference is moved to the split-off loose variable, which is given the array dimension itself. When passing things around inside the shader, such as over a function call, the the original type is used in a sanitized form that removes the builtIn qualifications and makes them temporaries. This means internal function calls do not have to change. However, the type when returned from the shader will be member-wise copied from the internal sanitized one to the external type. The sanitized type is used in variable declarations. When copying split types and unsplit, if a sub-struct contains only user variables, it is copied as a single entity to avoid more AST verbosity. Above strategy arrived at with talks with @johnkslang. This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to real world cases.
2016-12-14 22:22:25 +00:00
{"hlsl.struct.split-1.vert", "main"},
HLSL: struct splitting: assignments of hierarchical split types This commit adds support for copying nested hierarchical types of split types. E.g, a struct of a struct containing both user and builtin interstage IO variables. When copying split types, if any subtree does NOT contain builtin interstage IO, we can copy the whole subtree with one assignment, which saves a bunch of AST verbosity for memberwise copies of that subtree.
2016-12-19 22:48:01 +00:00
{"hlsl.struct.split.array.geom", "main"},
HLSL: fix dereferencing when copying split structures with arrays When copying split types with mixtures of user variables and buitins, where the builtins are extracted, there is a parallel structures traversal. The traversal was not obtaining the derefenced types in the array case.
2017-01-19 22:18:00 +00:00
{"hlsl.struct.split.assign.frag", "main"},
HLSL: inter-stage structure splitting. This adds structure splitting, which among other things will enable GS support where input structs are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case. The salient points of this PR are: * Structure splitting has been changed from "always between stages" to "only into the VS and out of the PS". It had previously happened between stages because it's not legal to pass a struct containing a builtin IO variable. * Structs passed between stages are now split into a struct containing ONLY user types, and a collection of loose builtin IO variables, if any. The user-part is passed as a normal struct between stages, which is valid SPIR-V now that the builtin IO is removed. * Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g, functions can work unmodified. * If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS, the array reference is moved to the split-off loose variable, which is given the array dimension itself. When passing things around inside the shader, such as over a function call, the the original type is used in a sanitized form that removes the builtIn qualifications and makes them temporaries. This means internal function calls do not have to change. However, the type when returned from the shader will be member-wise copied from the internal sanitized one to the external type. The sanitized type is used in variable declarations. When copying split types and unsplit, if a sub-struct contains only user variables, it is copied as a single entity to avoid more AST verbosity. Above strategy arrived at with talks with @johnkslang. This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to real world cases.
2016-12-14 22:22:25 +00:00
{"hlsl.struct.split.call.vert", "main"},
HLSL: struct splitting: assignments of hierarchical split types This commit adds support for copying nested hierarchical types of split types. E.g, a struct of a struct containing both user and builtin interstage IO variables. When copying split types, if any subtree does NOT contain builtin interstage IO, we can copy the whole subtree with one assignment, which saves a bunch of AST verbosity for memberwise copies of that subtree.
2016-12-19 22:48:01 +00:00
{"hlsl.struct.split.nested.geom", "main"},
HLSL: fix copies between arrays of structs of builtins, and arrayed builtins. Structs are split to remove builtin members to create valid SPIR-V. In this process, an outer structure array dimension may be propegated onto the now-removed builtin variables. For example, a mystruct[3].position -> position[3]. The copy between the split and unsplit forms would handle this in some cases, but not if the array dimension was at different levels of aggregate. It now does this, but may not handle arbitrary composite types. Unclear if that has any semantic meaning for builtins though.
2017-02-02 23:32:02 +00:00
{"hlsl.struct.split.trivial.geom", "main"},
HLSL: inter-stage structure splitting. This adds structure splitting, which among other things will enable GS support where input structs are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case. The salient points of this PR are: * Structure splitting has been changed from "always between stages" to "only into the VS and out of the PS". It had previously happened between stages because it's not legal to pass a struct containing a builtin IO variable. * Structs passed between stages are now split into a struct containing ONLY user types, and a collection of loose builtin IO variables, if any. The user-part is passed as a normal struct between stages, which is valid SPIR-V now that the builtin IO is removed. * Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g, functions can work unmodified. * If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS, the array reference is moved to the split-off loose variable, which is given the array dimension itself. When passing things around inside the shader, such as over a function call, the the original type is used in a sanitized form that removes the builtIn qualifications and makes them temporaries. This means internal function calls do not have to change. However, the type when returned from the shader will be member-wise copied from the internal sanitized one to the external type. The sanitized type is used in variable declarations. When copying split types and unsplit, if a sub-struct contains only user variables, it is copied as a single entity to avoid more AST verbosity. Above strategy arrived at with talks with @johnkslang. This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to real world cases.
2016-12-14 22:22:25 +00:00
{"hlsl.struct.split.trivial.vert", "main"},
HLSL: Recursive composite flattening This PR implements recursive type flattening. For example, an array of structs of other structs can be flattened to individual member variables at the shader interface. This is sufficient for many purposes, e.g, uniforms containing opaque types, but is not sufficient for geometry shader arrayed inputs. That will be handled separately with structure splitting, which is not implemented by this PR. In the meantime, that case is detected and triggers an error. The recursive flattening extends the following three aspects of single-level flattening: - Flattening of structures to individual members with names such as "foo[0].samp[1]"; - Turning constant references to the nested composite type into a reference to a particular flattened member. - Shadow copies between arrays of flattened members and the nested composite type. Previous single-level flattening only flattened at the shader interface, and that is unchanged by this PR. Internally, shadow copies are, such as if the type is passed to a function. Also, the reasons for flattening are unchanged. Uniforms containing opaque types, and interface struct types are flattened. (The latter will change with structure splitting). One existing test changes: hlsl.structin.vert, which did in fact contain a nested composite type to be flattened. Two new tests are added: hlsl.structarray.flatten.frag, and hlsl.structarray.flatten.geom (currently issues an error until type splitting is online). The process of arriving at the individual member from chained postfix expressions is more complex than it was with one level. See large-ish comment above HlslParseContext::flatten() for details.
2016-11-29 00:09:54 +00:00
{"hlsl.structarray.flatten.frag", "main"},
{"hlsl.structarray.flatten.geom", "main"},
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
{"hlsl.structbuffer.frag", "main"},
WIP: HLSL: add Append/ConsumeBuffer support
2017-04-14 00:42:58 +00:00
{"hlsl.structbuffer.append.frag", "main"},
WIP: HLSL: add ability to pass struct buffers with counters to fns This modifies function parameter passing to pass the counter buffer associated with a struct buffer to a function as a hidden parameter. Similarly function declarations will have hidden parameters added to accept the associated counter buffers. There is a limitation: if a SB type may or may not have an associated counter, passing it as a function parameter will assume that it does, and the counter will appear in the linkage whether or not there is a counter method used on the object.
2017-04-27 17:22:32 +00:00
{"hlsl.structbuffer.append.fn.frag", "main"},
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
{"hlsl.structbuffer.atomics.frag", "main"},
{"hlsl.structbuffer.byte.frag", "main"},
{"hlsl.structbuffer.coherent.frag", "main"},
HLSL: cast non-int types to uint on Load/Store indexes Some texture and SB operations can take non-integer indexes, which should be cast to integers before use if they are not already. This adds makeIntegerIndex() for the purpose. Int types are left alone. (This was done before for operator[], but needs to apply to some other things too, hence its extraction into common function now)
2017-04-20 15:00:56 +00:00
{"hlsl.structbuffer.floatidx.comp", "main"},
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
{"hlsl.structbuffer.incdec.frag", "main"},
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
{"hlsl.structbuffer.fn.frag", "main"},
HLSL: fix for byte address buffers in fn parmeters Byte address buffers were failing to detect that they were byte address buffers when used as fn parameters. Note: this detection is a little awkward, and could be simplified if it was easy to obtain the declared builtin type for an object.
2017-04-20 22:37:14 +00:00
{"hlsl.structbuffer.fn2.comp", "main"},
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
{"hlsl.structbuffer.rw.frag", "main"},
{"hlsl.structbuffer.rwbyte.frag", "main"},
HLSL: Flatten vertex input and fragment output structures. Vulkan can't handle structures into the vertex stage or out of the fragment stage.
2016-09-09 22:32:09 +00:00
{"hlsl.structin.vert", "main"},
HLSL: Add tests and refine what decorations are passed through per stage/in/out.
2017-02-07 01:44:52 +00:00
{"hlsl.structIoFourWay.frag", "main"},
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
{"hlsl.structStructName.frag", "main"},
HLSL: add subpass input types and methods Add support for Subpass Input proposal of issue #1069. Subpass input types are given as: layout(input_attachment_index = 1) SubpassInput<float4> subpass_f; layout(input_attachment_index = 2) SubpassInput<int4> subpass_i; layout(input_attachment_index = 3) SubpassInput<uint4> subpass_u; layout(input_attachment_index = 1) SubpassInputMS<float4> subpass_ms_f; layout(input_attachment_index = 2) SubpassInputMS<int4> subpass_ms_i; layout(input_attachment_index = 3) SubpassInputMS<uint4> subpass_ms_u; The input attachment may also be specified using attribute syntax: [[vk::input_attachment_index(7)]] SubpassInput subpass_2; The template type may be a shorter-than-vec4 vector, but currently user structs are not supported. (An unimplemented error will be issued). The load operations are methods on objects of the above type: float4 result = subpass_f.SubpassLoad(); int4 result = subpass_i.SubpassLoad(); uint4 result = subpass_u.SubpassLoad(); float4 result = subpass_ms_f.SubpassLoad(samp); int4 result = subpass_ms_i.SubpassLoad(samp); uint4 result = subpass_ms_u.SubpassLoad(samp); Additionally, the AST printer could not print EOpSubpass* nodes. Now it can. Fixes #1069
2017-09-27 15:04:43 +00:00
{"hlsl.subpass.frag", "main"},
HLSL: Broaden solution for #940, editing integer input for 'flat'.
2017-06-21 07:35:57 +00:00
{"hlsl.synthesizeInput.frag", "main"},
HLSL: add methods to track user structure in texture return type. Some languages allow a restricted set of user structure types returned from texture sampling operations. Restrictions include the total vector size of all components may not exceed 4, and the basic types of all members must be identical. This adds underpinnings for that ability. Because storing a whole TType or even a simple TTypeList in the TSampler would be expensive, the structure definition is held in a table outside the TType. The TSampler contains a small bitfield index, currently 4 bits to support up to 15 separate texture template structure types, but that can be adjusted up or down. Vector returns are handled as before. There are abstraction methods accepting and returning a TType (such as may have been parsed from a grammar). The new methods will accept a texture template type and set the sampler to the structure if possible, checking a range of error conditions such as whether the total structure vector components exceed 4, or whether their basic types differe, or whether the struct contains non-vector-or-scalar members. Another query returns the appropriate TType for the sampler. High level summary of design: In the TSampler, this holds an index into the texture structure return type table: unsigned int structReturnIndex : structReturnIndexBits; These are the methods to set or get the return type from the TSampler. They work for vector or structure returns, and potentially could be expanded to handle other things (small arrays?) if ever needed. bool setTextureReturnType(TSampler& sampler, const TType& retType, const TSourceLoc& loc); void getTextureReturnType(const TSampler& sampler, const TType& retType, const TSourceLoc& loc) const; The ``convertReturn`` lambda in ``HlslParseContext::decomposeSampleMethods`` is greatly expanded to know how to copy a vec4 sample return to whatever the structure type should be. This is a little awkward since it involves introducing a comma expression to return the proper aggregate value after a set of memberwise copies.
2017-07-31 19:41:42 +00:00
{"hlsl.texture.struct.frag", "main"},
HLSL: add test coverage for sub-vec4 texture intrinsics This changes no functional code. There was a bit of a testing hole in that textures templatized on sub-vec4 types were not being exercised with any intrinsics. This adds some basic sanity coverage of that case.
2017-06-01 19:10:25 +00:00
{"hlsl.texture.subvec4.frag", "main"},
HLSL: Implement 'this' keyword.
2017-03-22 17:38:22 +00:00
{"hlsl.this.frag", "main"},
Add negative intrinsics tests
2016-06-03 16:53:28 +00:00
{"hlsl.intrinsics.vert", "VertexShaderFunction"},
HLSL: Move frexp() to a separate test file.
2017-03-29 09:04:58 +00:00
{"hlsl.intrinsic.frexp.vert", "VertexShaderFunction"},
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
{"hlsl.matType.frag", "PixelShaderFunction"},
HLSL: use HLSL parser to parse HLSL intrinsic prototypes, enable int/bool mats This PR adds a CreateParseContext() fn analogous to CreateBuiltInParseables(), to create a language specific built in parser. (This code was present before but not encapsualted in a fn). This can now be used to create a source language specific parser for builtins. Along with this, the code creating HLSL intrinsic prototypes can now produce them in HLSL syntax, rather than GLSL syntax. This relaxes certain prior restrictions at the parser level. Lower layers (e.g, SPIR-V) may still have such restrictions, such as around Nx1 matrices: this code does not impact that. This PR also fleshes out matrix types for bools and ints, both of which were partially in place before. This was easier than maintaining the restrictions in the HLSL prototype generator to avoid creating protoypes with those types. Many tests change because the result type from intrinsics moves from "global" to "temp". Several new tests are added for the new types.
2016-11-15 17:11:04 +00:00
{"hlsl.matType.bool.frag", "main"},
{"hlsl.matType.int.frag", "main"},
Tests: Add a set of gtest-file-based HLSL tests.
2016-05-16 23:39:50 +00:00
{"hlsl.max.frag", "PixelShaderFunction"},
HLSL: fix preprocessor concatenation behaviour. Fix #772.
2017-08-24 06:28:57 +00:00
{"hlsl.preprocessor.frag", "main"},
Tests: Add a set of gtest-file-based HLSL tests.
2016-05-16 23:39:50 +00:00
{"hlsl.precedence.frag", "PixelShaderFunction"},
{"hlsl.precedence2.frag", "PixelShaderFunction"},
HLSL: fix several issues in mat construction from scalars This fixes: 1. A compilation error when assigning scalars to matricies 2. A semantic error in matrix construction from scalars. This was initializing the diagonal, where HLSL semantics require the scalar be replicated to every matrix element. 3. Functions accepting mats can be called with scalars, which will be shape-converted to the matrix type. This was previously failing to match the function signature. NOTE: this does not yet handle complex scalars (a function call, say) used to construct matricies. That'll be added when the node replicator service is available. For now, there's an assert. There's one new test (hlsl.scalar2matrix.frag). An existing test lsl.type.half.frag changes, because of (2) above, and a negative test error message changes due to (3) above. Fixes #923.
2017-06-09 20:36:46 +00:00
{"hlsl.scalar2matrix.frag", "main"},
HLSL: Accept SV_Cull/ClipDistanceN, by refactoring the way semantics are mapped.
2017-03-09 21:37:32 +00:00
{"hlsl.semantic.geom", "main"},
{"hlsl.semantic.vert", "main"},
HLSL: fix preprocessor concatenation behaviour. Fix #772.
2017-08-24 06:28:57 +00:00
{"hlsl.semantic-1.vert", "main"},
HLSL: Implement proper nesting of symbol-table scopes and identifier searching.
2016-06-09 08:02:17 +00:00
{"hlsl.scope.frag", "PixelShaderFunction"},
Tests: Add a set of gtest-file-based HLSL tests.
2016-05-16 23:39:50 +00:00
{"hlsl.sin.frag", "PixelShaderFunction"},
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
{"hlsl.struct.frag", "PixelShaderFunction"},
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
{"hlsl.switch.frag", "PixelShaderFunction"},
HLSL: Handle "." for structure dereference and swizzle.
2016-06-17 23:16:27 +00:00
{"hlsl.swizzle.frag", "PixelShaderFunction"},
HLSL: Fix #942: Map SV_TargetN to SPV Location N.
2017-06-27 21:17:38 +00:00
{"hlsl.target.frag", "main"},
{"hlsl.targetStruct1.frag", "main"},
{"hlsl.targetStruct2.frag", "main"},
HLSL: Add template style constructors for vector & matrix types
2016-06-24 01:13:48 +00:00
{"hlsl.templatetypes.frag", "PixelShaderFunction"},
HLSL: phase 2d: minor cleanup, & allow operator[] on non-rw textures Improve comments. A few tweaked lines allow [] on non-rw tx. Add test case for this. Improve VectorTimesScalar handling.
2016-10-10 16:00:14 +00:00
{"hlsl.tx.bracket.frag", "main"},
HLSL: allow name mangling based on texture template type Name mangling did not account for the vector size in the template type of a texture. This adds that. The mangle is as it ever was for the vec4 case, which leaves all GLSL behavior and most HLSL behavior uneffected. For vec1-3 the size is added to the mangle. Current limitation: textures cannot presently be templatized on structured types, so this works only for vectors of basic types. Fixes #895.
2017-05-18 23:43:08 +00:00
{"hlsl.tx.overload.frag", "main"},
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
{"hlsl.type.half.frag", "main"},
{"hlsl.type.identifier.frag", "main"},
AST: Have type deepCopy() preserve type graphs as graphs. Previously, a type graph would turn into a type tree. That is, a deep node that is shared would have multiple copies made. This is important when creating IO and non-IO versions of deep types.
2017-02-01 20:14:03 +00:00
{"hlsl.typeGraphCopy.vert", "main"},
HLSL: Add typedef grammar and production.
2016-07-05 06:02:40 +00:00
{"hlsl.typedef.frag", "PixelShaderFunction"},
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
{"hlsl.whileLoop.frag", "PixelShaderFunction"},
HLSL: Manually configure descriptor set and binding number for resources
2017-05-02 07:27:29 +00:00
{"hlsl.void.frag", "PixelShaderFunction"}
Add support for testing file-based HLSL source code in GTest.
2016-05-16 16:50:30 +00:00
}),
FileNameAsCustomTestSuffix
);
// clang-format on
Flatten uniform arrays This checkin adds a --flatten-uniform-arrays option which can break uniform arrays of samplers, textures, or UBOs up into individual scalars named (e.g) myarray[0], myarray[1], etc. These appear as individual linkage objects. Code notes: - shouldFlatten internally calls shouldFlattenIO, and shouldFlattenUniform, but is the only flattening query directly called. - flattenVariable will handle structs or arrays (but not yet arrayed structs; this is tested an an error is generated). - There's some error checking around unhandled situations. E.g, flattening uniform arrays with initializer lists is not implemented. - This piggybacks on as much of the existing mechanism for struct flattening as it can. E.g, it uses the same flattenMap, and the same flattenAccess() method. - handleAssign() has been generalized to cope with either structs or arrays. - Extended test infrastructure to test flattening ability.
2016-09-16 19:26:37 +00:00
// clang-format off
INSTANTIATE_TEST_CASE_P(
ToSpirv, HlslCompileAndFlattenTest,
::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
{"hlsl.array.flatten.frag", "main"},
HLSL: Partially flatten hierarchies, instead of all or nothing. Fixes #1092. Allows arrays of opaques to keep arrayness, unless needed by uniform array flattening. Can handle assignments of mixed amounts of flattening.
2017-10-11 20:03:45 +00:00
{"hlsl.partialFlattenMixed.vert", "main"},
Flatten uniform arrays This checkin adds a --flatten-uniform-arrays option which can break uniform arrays of samplers, textures, or UBOs up into individual scalars named (e.g) myarray[0], myarray[1], etc. These appear as individual linkage objects. Code notes: - shouldFlatten internally calls shouldFlattenIO, and shouldFlattenUniform, but is the only flattening query directly called. - flattenVariable will handle structs or arrays (but not yet arrayed structs; this is tested an an error is generated). - There's some error checking around unhandled situations. E.g, flattening uniform arrays with initializer lists is not implemented. - This piggybacks on as much of the existing mechanism for struct flattening as it can. E.g, it uses the same flattenMap, and the same flattenAccess() method. - handleAssign() has been generalized to cope with either structs or arrays. - Extended test infrastructure to test flattening ability.
2016-09-16 19:26:37 +00:00
}),
FileNameAsCustomTestSuffix
);
Enable HLSL legalization Also added known-good mechanism to fetch latest validated spirv-tools. Also added -Od and -Os to disable optimizer and optimize for size. Fetching spirv-tools is optional for both glsl and hlsl. Legalization of hlsl is done by default if spirv-opt is present at cmake time. Optimization for glsl is currently done through the option -Os. Legalization testing is currently only done on four existing shaders. A separate baseLegalResults directory holds those results. All previous testing is done with the optimizer disabled.
2017-09-22 00:40:22 +00:00
// clang-format on
Flatten uniform arrays This checkin adds a --flatten-uniform-arrays option which can break uniform arrays of samplers, textures, or UBOs up into individual scalars named (e.g) myarray[0], myarray[1], etc. These appear as individual linkage objects. Code notes: - shouldFlatten internally calls shouldFlattenIO, and shouldFlattenUniform, but is the only flattening query directly called. - flattenVariable will handle structs or arrays (but not yet arrayed structs; this is tested an an error is generated). - There's some error checking around unhandled situations. E.g, flattening uniform arrays with initializer lists is not implemented. - This piggybacks on as much of the existing mechanism for struct flattening as it can. E.g, it uses the same flattenMap, and the same flattenAccess() method. - handleAssign() has been generalized to cope with either structs or arrays. - Extended test infrastructure to test flattening ability.
2016-09-16 19:26:37 +00:00
Legalization: Fix warnings and disable tests when spirv-tools not present
2017-09-28 16:08:32 +00:00
#ifdef ENABLE_OPT
Enable HLSL legalization Also added known-good mechanism to fetch latest validated spirv-tools. Also added -Od and -Os to disable optimizer and optimize for size. Fetching spirv-tools is optional for both glsl and hlsl. Legalization of hlsl is done by default if spirv-opt is present at cmake time. Optimization for glsl is currently done through the option -Os. Legalization testing is currently only done on four existing shaders. A separate baseLegalResults directory holds those results. All previous testing is done with the optimizer disabled.
2017-09-22 00:40:22 +00:00
// clang-format off
INSTANTIATE_TEST_CASE_P(
ToSpirv, HlslLegalizeTest,
::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
{"hlsl.aliasOpaque.frag", "main"},
{"hlsl.flattenOpaque.frag", "main"},
{"hlsl.flattenOpaqueInit.vert", "main"},
HLSL: Tests: Add subset of flattened opaque test to legalize results.
2017-10-07 03:01:07 +00:00
{"hlsl.flattenOpaqueInitMix.vert", "main"},
{"hlsl.flattenSubset.frag", "main"}
Enable HLSL legalization Also added known-good mechanism to fetch latest validated spirv-tools. Also added -Od and -Os to disable optimizer and optimize for size. Fetching spirv-tools is optional for both glsl and hlsl. Legalization of hlsl is done by default if spirv-opt is present at cmake time. Optimization for glsl is currently done through the option -Os. Legalization testing is currently only done on four existing shaders. A separate baseLegalResults directory holds those results. All previous testing is done with the optimizer disabled.
2017-09-22 00:40:22 +00:00
}),
FileNameAsCustomTestSuffix
);
Flatten uniform arrays This checkin adds a --flatten-uniform-arrays option which can break uniform arrays of samplers, textures, or UBOs up into individual scalars named (e.g) myarray[0], myarray[1], etc. These appear as individual linkage objects. Code notes: - shouldFlatten internally calls shouldFlattenIO, and shouldFlattenUniform, but is the only flattening query directly called. - flattenVariable will handle structs or arrays (but not yet arrayed structs; this is tested an an error is generated). - There's some error checking around unhandled situations. E.g, flattening uniform arrays with initializer lists is not implemented. - This piggybacks on as much of the existing mechanism for struct flattening as it can. E.g, it uses the same flattenMap, and the same flattenAccess() method. - handleAssign() has been generalized to cope with either structs or arrays. - Extended test infrastructure to test flattening ability.
2016-09-16 19:26:37 +00:00
// clang-format on
Legalization: Fix warnings and disable tests when spirv-tools not present
2017-09-28 16:08:32 +00:00
#endif
Enable HLSL legalization Also added known-good mechanism to fetch latest validated spirv-tools. Also added -Od and -Os to disable optimizer and optimize for size. Fetching spirv-tools is optional for both glsl and hlsl. Legalization of hlsl is done by default if spirv-opt is present at cmake time. Optimization for glsl is currently done through the option -Os. Legalization testing is currently only done on four existing shaders. A separate baseLegalResults directory holds those results. All previous testing is done with the optimizer disabled.
2017-09-22 00:40:22 +00:00
Add support for testing file-based HLSL source code in GTest.
2016-05-16 16:50:30 +00:00
} // anonymous namespace
} // namespace glslangtest
Reference in New Issue Copy Permalink