AuroraMiddleware/glslang
1
0
Fork 0
mirror of https://github.com/KhronosGroup/glslang synced 2024-11-12 21:20:06 +00:00
Code Issues Packages Projects Releases Wiki Activity
1c573fbcfb
glslang/gtests/Hlsl.FromFile.cpp

237 lines
10 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>>;
Add support for testing file-based HLSL source code in GTest.
2016-05-16 16:50:30 +00:00
// Compiling HLSL to SPIR-V under Vulkan semantics. Expected to successfully
Fix several comments in GTest fixture.
2016-05-17 20:43:05 +00:00
// 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);
}
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: 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: 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: 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: 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: Fix a grammar error related to constructors in parenthetical expressions
2016-07-30 13:38:55 +00:00
{"hlsl.constructexpr.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: 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"},
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"},
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"},
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"},
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: 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"},
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 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"},
Add HLSL memory barrier intrinsics, fix dst, add lit & EvaluateAttributeSnapped
2016-06-15 15:50:24 +00:00
{"hlsl.intrinsics.f1632.frag", "PixelShaderFunction"},
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"},
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: 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"},
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.unary.frag", "main"},
{"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: 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: 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: 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"},
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: 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.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.samplecmp.offset.dx10.frag", "main"},
{"hlsl.samplecmp.offsetarray.dx10.frag", "main"},
{"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 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 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: 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"},
Add negative intrinsics tests
2016-06-03 16:53:28 +00:00
{"hlsl.intrinsics.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.precedence.frag", "PixelShaderFunction"},
{"hlsl.precedence2.frag", "PixelShaderFunction"},
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: 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: 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: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +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"},
}),
FileNameAsCustomTestSuffix
);
// clang-format on
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